'num2epoch', 'mx2num', 'DateFormatter',

'IndexDateFormatter', 'AutoDateFormatter', 'DateLocator',

'RRuleLocator', 'AutoDateLocator', 'YearLocator',

'MonthLocator', 'WeekdayLocator',

'DayLocator', 'HourLocator', 'MinuteLocator',

'SecondLocator', 'MicrosecondLocator',

'rrule', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU',

'YEARLY', 'MONTHLY', 'WEEKLY', 'DAILY',

'HOURLY', 'MINUTELY', 'SECONDLY', 'MICROSECONDLY', 'relativedelta',

"""UTC"""

def utcoffset(self, dt):

return datetime.timedelta(0)

def tzname(self, dt):

return str("UTC")

def dst(self, dt):

"""

s = matplotlib.rcParams['timezone']

if s == 'UTC':

return UTC

import pytz

"""

# Convert to UTC

tzi = getattr(dt, 'tzinfo', None)

if tzi is not None:

dt = dt.astimezone(UTC)

tzi = UTC

base = float(dt.toordinal())

# If it's sufficiently datetime-like, it will have a `date()` method

cdate = getattr(dt, 'date', lambda: None)()

if cdate is not None:

# Get a datetime object at midnight UTC

midnight_time = datetime.time(0, tzinfo=tzi)

rdt = datetime.datetime.combine(cdate, midnight_time)

# Append the seconds as a fraction of a day

base += (dt - rdt).total_seconds() / SEC_PER_DAY

"""

# the "extra" ensures that we at least allow the dynamic range out to

# seconds. That should get out to +/-2e11 years.

# NOTE: First cast truncates; second cast back is for NumPy 1.10.

extra = d - d.astype('datetime64[s]').astype(d.dtype)

extra = extra.astype('timedelta64[ns]')

t0 = np.datetime64('0001-01-01T00:00:00').astype('datetime64[s]')

dt = (d.astype('datetime64[s]') - t0).astype(np.float64)

dt += extra.astype(np.float64) / 1.0e9

dt = dt / SEC_PER_DAY + 1.0

NaT_int = np.datetime64('NaT').astype(np.int64)

d_int = d.astype(np.int64)

try:

dt[d_int == NaT_int] = np.nan

except TypeError:

if d_int == NaT_int:

dt = np.nan

"""

if tz is None:

tz = _get_rc_timezone()

ix, remainder = divmod(x, 1)

ix = int(ix)

if ix < 1:

raise ValueError('Cannot convert {} to a date. This often happens if '

'non-datetime values are passed to an axis that '

'expects datetime objects.'.format(ix))

dt = datetime.datetime.fromordinal(ix).replace(tzinfo=UTC)

# Since the input date `x` float is unable to preserve microsecond

# precision of time representation in non-antique years, the

# resulting datetime is rounded to the nearest multiple of

# `musec_prec`. A value of 20 is appropriate for current dates.

musec_prec = 20

remainder_musec = int(round(remainder * MUSECONDS_PER_DAY / musec_prec)

* musec_prec)

# For people trying to plot with full microsecond precision, enable

# an early-year workaround

if x < 30 * 365:

remainder_musec = int(round(remainder * MUSECONDS_PER_DAY))

# add hours, minutes, seconds, microseconds

dt += datetime.timedelta(microseconds=remainder_musec)

"""

def __init__(self, fmt):

""" fmt: any valid strptime format is supported """

self.fmt = fmt

def __call__(self, s):

"""s : string to be converted

"""

def __init__(self, fmt, encoding='utf-8'):

"""

super().__init__(fmt)

self.encoding = encoding

def __call__(self, b):

"""

s = b.decode(self.encoding)

"""

if isinstance(d, str):

dt = dateutil.parser.parse(d, default=default)

return date2num(dt)

else:

if default is not None:

d = [dateutil.parser.parse(s, default=default) for s in d]

d = np.asarray(d)

if not d.size:

return d

"""

if hasattr(d, "values"):

# this unpacks pandas series or dataframes...

d = d.values

if ((isinstance(d, np.ndarray) and np.issubdtype(d.dtype, np.datetime64))

or isinstance(d, np.datetime64)):

return _dt64_to_ordinalf(d)

if not cbook.iterable(d):

return _to_ordinalf(d)

else:

d = np.asarray(d)

if not d.size:

return d

"""

if cbook.iterable(j):

j = np.asarray(j)

"""

if cbook.iterable(n):

n = np.asarray(n)

"""

if tz is None:

tz = _get_rc_timezone()

if not cbook.iterable(x):

return _from_ordinalf(x, tz)

else:

x = np.asarray(x)

if not x.size:

return x

"""

if not cbook.iterable(x):

return _ordinalf_to_timedelta(x)

else:

x = np.asarray(x)

if not x.size:

return x

"""

f1 = date2num(dstart)

f2 = date2num(dend)

step = delta.total_seconds() / SEC_PER_DAY

# calculate the difference between dend and dstart in times of delta

num = int(np.ceil((f2 - f1) / step))

# calculate end of the interval which will be generated

dinterval_end = dstart + num * delta

# ensure, that an half open interval will be generated [dstart, dend)

if dinterval_end >= dend:

# if the endpoint is greated than dend, just subtract one delta

dinterval_end -= delta

num -= 1

f2 = date2num(dinterval_end) # new float-endpoint

"""

illegal_s = re.compile(r"((^|[^%])(%%)*%s)")

def __init__(self, fmt, tz=None):

"""

if tz is None:

tz = _get_rc_timezone()

self.fmt = fmt

self.tz = tz

def __call__(self, x, pos=0):

if x == 0:

raise ValueError('DateFormatter found a value of x=0, which is '

'an illegal date; this usually occurs because '

'you have not informed the axis that it is '

'plotting dates, e.g., with ax.xaxis_date()')

return num2date(x, self.tz).strftime(self.fmt)

def set_tzinfo(self, tz):

self.tz = tz

@cbook.deprecated("3.0")

def _replace_common_substr(self, s1, s2, sub1, sub2, replacement):

"""Helper function for replacing substrings sub1 and sub2

# Find common indexes of substrings sub1 in s1 and sub2 in s2

# and make substitutions inplace. Because this is inplace,

# it is okay if len(replacement) != len(sub1), len(sub2).

i = 0

while True:

j = s1.find(sub1, i)

if j == -1:

break

i = j + 1

if s2[j:j + len(sub2)] != sub2:

continue

s1 = s1[:j] + replacement + s1[j + len(sub1):]

s2 = s2[:j] + replacement + s2[j + len(sub2):]

return s1, s2

@cbook.deprecated("3.0")

def strftime_pre_1900(self, dt, fmt=None):

"""Call time.strftime for years before 1900 by rolling

if fmt is None:

fmt = self.fmt

# Since python's time module's strftime implementation does not

# support %f microsecond (but the datetime module does), use a

# regular expression substitution to replace instances of %f.

# Note that this can be useful since python's floating-point

# precision representation for datetime causes precision to be

# more accurate closer to year 0 (around the year 2000, precision

# can be at 10s of microseconds).

fmt = re.sub(r'((^|[^%])(%%)*)%f',

r'\g<1>{0:06d}'.format(dt.microsecond), fmt)

year = dt.year

# For every non-leap year century, advance by

# 6 years to get into the 28-year repeat cycle

delta = 2000 - year

off = 6 * (delta // 100 + delta // 400)

year = year + off

# Move to between the years 1973 and 2000

year1 = year + ((2000 - year) // 28) * 28

year2 = year1 + 28

timetuple = dt.timetuple()

# Generate timestamp string for year and year+28

s1 = time.strftime(fmt, (year1,) + timetuple[1:])

s2 = time.strftime(fmt, (year2,) + timetuple[1:])

# Replace instances of respective years (both 2-digit and 4-digit)

# that are located at the same indexes of s1, s2 with dt's year.

# Note that C++'s strftime implementation does not use padded

# zeros or padded whitespace for %y or %Y for years before 100, but

# uses padded zeros for %x. (For example, try the runnable examples

# with .tm_year in the interval [-1900, -1800] on

# http://en.cppreference.com/w/c/chrono/strftime.) For ease of

# implementation, we always use padded zeros for %y, %Y, and %x.

s1, s2 = self._replace_common_substr(s1, s2,

"{0:04d}".format(year1),

"{0:04d}".format(year2),

"{0:04d}".format(dt.year))

s1, s2 = self._replace_common_substr(s1, s2,

"{0:02d}".format(year1 % 100),

"{0:02d}".format(year2 % 100),

"{0:02d}".format(dt.year % 100))

return cbook.unicode_safe(s1)

@cbook.deprecated("3.0")

def strftime(self, dt, fmt=None):

"""

if fmt is None:

fmt = self.fmt

fmt = self.illegal_s.sub(r"\1", fmt)

fmt = fmt.replace("%s", "s")

if dt.year >= 1900:

# Note: in python 3.3 this is okay for years >= 1000,

# refer to http://bugs.python.org/issue1777412

return cbook.unicode_safe(dt.strftime(fmt))

"""

def __init__(self, t, fmt, tz=None):

"""

if tz is None:

tz = _get_rc_timezone()

self.t = t

self.fmt = fmt

self.tz = tz

def __call__(self, x, pos=0):

'Return the label for time *x* at position *pos*'

ind = int(np.round(x))

if ind >= len(self.t) or ind <= 0:

return ''

"""

# This can be improved by providing some user-level direction on

# how to choose the best format (precedence, etc...)

# Perhaps a 'struct' that has a field for each time-type where a

# zero would indicate "don't show" and a number would indicate

# "show" with some sort of priority. Same priorities could mean

# show all with the same priority.

# Or more simply, perhaps just a format string for each

# possibility...

def __init__(self, locator, tz=None, defaultfmt='%Y-%m-%d'):

"""

self._locator = locator

self._tz = tz

self.defaultfmt = defaultfmt

self._formatter = DateFormatter(self.defaultfmt, tz)

self.scaled = {DAYS_PER_YEAR: rcParams['date.autoformatter.year'],

DAYS_PER_MONTH: rcParams['date.autoformatter.month'],

1.0: rcParams['date.autoformatter.day'],

1. / HOURS_PER_DAY: rcParams['date.autoformatter.hour'],

1. / (MINUTES_PER_DAY):

rcParams['date.autoformatter.minute'],

1. / (SEC_PER_DAY):

rcParams['date.autoformatter.second'],

1. / (MUSECONDS_PER_DAY):

rcParams['date.autoformatter.microsecond']}

def __call__(self, x, pos=None):

locator_unit_scale = float(self._locator._get_unit())

# Pick the first scale which is greater than the locator unit.

fmt = next((fmt for scale, fmt in sorted(self.scaled.items())

if scale >= locator_unit_scale),

self.defaultfmt)

if isinstance(fmt, str):

self._formatter = DateFormatter(fmt, self._tz)

result = self._formatter(x, pos)

elif callable(fmt):

result = fmt(x, pos)

else:

raise TypeError('Unexpected type passed to {0!r}.'.format(self))

def __init__(self, freq, tzinfo=None, **kwargs):

kwargs['freq'] = freq

self._base_tzinfo = tzinfo

self._update_rrule(**kwargs)

def set(self, **kwargs):

self._construct.update(kwargs)

self._update_rrule(**self._construct)

def _update_rrule(self, **kwargs):

tzinfo = self._base_tzinfo

# rrule does not play nicely with time zones - especially pytz time

# zones, it's best to use naive zones and attach timezones once the

# datetimes are returned

if 'dtstart' in kwargs:

dtstart = kwargs['dtstart']

if dtstart.tzinfo is not None:

if tzinfo is None:

tzinfo = dtstart.tzinfo

else:

dtstart = dtstart.astimezone(tzinfo)

kwargs['dtstart'] = dtstart.replace(tzinfo=None)

if 'until' in kwargs:

until = kwargs['until']

if until.tzinfo is not None:

if tzinfo is not None:

until = until.astimezone(tzinfo)

else:

raise ValueError('until cannot be aware if dtstart '

'is naive and tzinfo is None')

kwargs['until'] = until.replace(tzinfo=None)

self._construct = kwargs.copy()

self._tzinfo = tzinfo

self._rrule = rrule(**self._construct)

def _attach_tzinfo(self, dt, tzinfo):

# pytz zones are attached by "localizing" the datetime

if hasattr(tzinfo, 'localize'):

return tzinfo.localize(dt, is_dst=True)

return dt.replace(tzinfo=tzinfo)

def _aware_return_wrapper(self, f, returns_list=False):

"""Decorator function that allows rrule methods to handle tzinfo."""

# This is only necessary if we're actually attaching a tzinfo

if self._tzinfo is None:

return f

# All datetime arguments must be naive. If they are not naive, they are

# converted to the _tzinfo zone before dropping the zone.

def normalize_arg(arg):

if isinstance(arg, datetime.datetime) and arg.tzinfo is not None:

if arg.tzinfo is not self._tzinfo:

arg = arg.astimezone(self._tzinfo)

return arg.replace(tzinfo=None)

return arg

def normalize_args(args, kwargs):

args = tuple(normalize_arg(arg) for arg in args)

kwargs = {kw: normalize_arg(arg) for kw, arg in kwargs.items()}

return args, kwargs

# There are two kinds of functions we care about - ones that return

# dates and ones that return lists of dates.

if not returns_list:

def inner_func(*args, **kwargs):

args, kwargs = normalize_args(args, kwargs)

dt = f(*args, **kwargs)

return self._attach_tzinfo(dt, self._tzinfo)

else:

def inner_func(*args, **kwargs):

args, kwargs = normalize_args(args, kwargs)

dts = f(*args, **kwargs)

return [self._attach_tzinfo(dt, self._tzinfo) for dt in dts]

return functools.wraps(f)(inner_func)

def __getattr__(self, name):

if name in self.__dict__:

return self.__dict__[name]

f = getattr(self._rrule, name)

if name in {'after', 'before'}:

return self._aware_return_wrapper(f)

elif name in {'xafter', 'xbefore', 'between'}:

return self._aware_return_wrapper(f, returns_list=True)

else:

return f

def __setstate__(self, state):

"""

hms0d = {'byhour': 0, 'byminute': 0, 'bysecond': 0}

def __init__(self, tz=None):

"""

if tz is None:

tz = _get_rc_timezone()

self.tz = tz

def set_tzinfo(self, tz):

"""

self.tz = tz

def datalim_to_dt(self):

"""

dmin, dmax = self.axis.get_data_interval()

if dmin > dmax:

dmin, dmax = dmax, dmin

if dmin < 1:

raise ValueError('datalim minimum {} is less than 1 and '