'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 "UTC"

def dst(self, dt):

"""

s = matplotlib.rcParams['timezone']

if s == 'UTC':

return UTC

import pytz

"""

if hasattr(dt, 'tzinfo') and dt.tzinfo is not None:

delta = dt.tzinfo.utcoffset(dt)

if delta is not None:

dt -= delta

base = float(dt.toordinal())

if isinstance(dt, datetime.datetime):

# Get a datetime object at midnight in the same time zone as dt.

cdate = dt.date()

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

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

td_remainder = _total_seconds(dt - rdt)

if td_remainder > 0:

base += td_remainder / SEC_PER_DAY

"""

return (tdelta.microseconds +

"""

if tz is None:

tz = _get_rc_timezone()

ix = int(x)

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

remainder = float(x) - ix

# Round down to the nearest microsecond.

dt += datetime.timedelta(microseconds=int(remainder * MUSECONDS_PER_DAY))

# Compensate for rounding errors

if dt.microsecond < 10:

dt = dt.replace(microsecond=0)

elif dt.microsecond > 999990:

dt += datetime.timedelta(microseconds=1e6 - dt.microsecond)

"""

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(bytespdate2num, self).__init__(fmt)

self.encoding = encoding

def __call__(self, b):

"""

s = b.decode(self.encoding)

"""

if cbook.is_string_like(d):

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 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

"""

f1 = _to_ordinalf(dstart)

f2 = _to_ordinalf(dend)

step = _total_seconds(delta) / 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 = _to_ordinalf(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()')

dt = num2date(x, self.tz)

return self.strftime(dt, self.fmt)

def set_tzinfo(self, tz):

self.tz = tz

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

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)

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

"""Refer to documentation for datetime.strftime.

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/issue177742

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(round(x))

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

return ''

dt = num2date(self.t[ind], self.tz)

"""

# 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: '%Y',

DAYS_PER_MONTH: '%b %Y',

1.0: '%b %d %Y',

1. / HOURS_PER_DAY: '%H:%M:%S',

1. / (MINUTES_PER_DAY): '%H:%M:%S.%f'}

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

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

fmt = self.defaultfmt

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

for possible_scale in sorted(self.scaled):

if possible_scale >= locator_unit_scale:

fmt = self.scaled[possible_scale]

break

if isinstance(fmt, six.string_types):

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

result = self._formatter(x, pos)

elif six.callable(fmt):

result = fmt(x, pos)

else:

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

def __init__(self, freq, **kwargs):

self._construct = kwargs.copy()

self._construct["freq"] = freq

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

def set(self, **kwargs):

self._construct.update(kwargs)

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

def __getattr__(self, name):

if name in self.__dict__:

return self.__dict__[name]

"""

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

return num2date(dmin, self.tz), num2date(dmax, self.tz)

def viewlim_to_dt(self):

"""

vmin, vmax = self.axis.get_view_interval()

if vmin > vmax:

vmin, vmax = vmax, vmin

return num2date(vmin, self.tz), num2date(vmax, self.tz)

def _get_unit(self):

"""

return 1

def _get_interval(self):

"""

return 1

def nonsingular(self, vmin, vmax):

"""

unit = self._get_unit()

interval = self._get_interval()

if abs(vmax - vmin) < 1e-6:

vmin -= 2 * unit * interval

vmax += 2 * unit * interval

# use the dateutil rrule instance

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

DateLocator.__init__(self, tz)

self.rule = o

def __call__(self):

# if no data have been set, this will tank with a ValueError

try:

dmin, dmax = self.viewlim_to_dt()

except ValueError:

return []

return self.tick_values(dmin, dmax)

def tick_values(self, vmin, vmax):

delta = relativedelta(vmax, vmin)

# We need to cap at the endpoints of valid datetime

try:

start = vmin - delta

except ValueError:

start = _from_ordinalf(1.0)

try:

stop = vmax + delta

except ValueError:

# The magic number!

stop = _from_ordinalf(3652059.9999999)

self.rule.set(dtstart=start, until=stop, count=self.MAXTICKS + 1)

# estimate the number of ticks very approximately so we don't

# have to do a very expensive (and potentially near infinite)

# 'between' calculation, only to find out it will fail.

nmax, nmin = date2num((vmax, vmin))

estimate = (nmax - nmin) / (self._get_unit() * self._get_interval())

# This estimate is only an estimate, so be really conservative

# about bailing...

if estimate > self.MAXTICKS * 2:

raise RuntimeError(

'RRuleLocator estimated to generate %d ticks from %s to %s: '

'exceeds Locator.MAXTICKS * 2 (%d) ' % (estimate, vmin, vmax,

self.MAXTICKS * 2))

dates = self.rule.between(vmin, vmax, True)

if len(dates) == 0:

return date2num([vmin, vmax])

return self.raise_if_exceeds(date2num(dates))

def _get_unit(self):

"""

freq = self.rule._rrule._freq

return self.get_unit_generic(freq)

@staticmethod

def get_unit_generic(freq):

if freq == YEARLY:

return DAYS_PER_YEAR

elif freq == MONTHLY:

return DAYS_PER_MONTH

elif freq == WEEKLY:

return DAYS_PER_WEEK

elif freq == DAILY:

return 1.0

elif freq == HOURLY:

return 1.0 / HOURS_PER_DAY

elif freq == MINUTELY:

return 1.0 / MINUTES_PER_DAY

elif freq == SECONDLY:

return 1.0 / SEC_PER_DAY

else:

# error

return -1 # or should this just return '1'?

def _get_interval(self):

return self.rule._rrule._interval

def autoscale(self):

"""

dmin, dmax = self.datalim_to_dt()

delta = relativedelta(dmax, dmin)

# We need to cap at the endpoints of valid datetime

try:

start = dmin - delta

except ValueError:

start = _from_ordinalf(1.0)

try:

stop = dmax + delta

except ValueError:

# The magic number!

stop = _from_ordinalf(3652059.9999999)

self.rule.set(dtstart=start, until=stop)

dmin, dmax = self.datalim_to_dt()

vmin = self.rule.before(dmin, True)

if not vmin:

vmin = dmin

vmax = self.rule.after(dmax, True)

if not vmax:

vmax = dmax

vmin = date2num(vmin)

vmax = date2num(vmax)

"""

def __init__(self, tz=None, minticks=5, maxticks=None,

interval_multiples=False):

"""

DateLocator.__init__(self, tz)

self._locator = YearLocator()

self._freq = YEARLY

self._freqs = [YEARLY, MONTHLY, DAILY, HOURLY, MINUTELY,

SECONDLY, MICROSECONDLY]

self.minticks = minticks

self.maxticks = {YEARLY: 11, MONTHLY: 12, DAILY: 11, HOURLY: 12,

MINUTELY: 11, SECONDLY: 11, MICROSECONDLY: 8}

if maxticks is not None:

try:

self.maxticks.update(maxticks)

except TypeError:

# Assume we were given an integer. Use this as the maximum

# number of ticks for every frequency and create a

# dictionary for this

self.maxticks = dict(zip(self._freqs,

[maxticks] * len(self._freqs)))

self.interval_multiples = interval_multiples

self.intervald = {

YEARLY: [1, 2, 4, 5, 10, 20, 40, 50, 100, 200, 400, 500,

1000, 2000, 4000, 5000, 10000],

MONTHLY: [1, 2, 3, 4, 6],

DAILY: [1, 2, 3, 7, 14, 21],

HOURLY: [1, 2, 3, 4, 6, 12],

MINUTELY: [1, 5, 10, 15, 30],

SECONDLY: [1, 5, 10, 15, 30],

MICROSECONDLY: [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000,

5000, 10000, 20000, 50000, 100000, 200000, 500000,

1000000]}