def trange_months(start, end, months):
""" Create a range of timestamps separated by a given number of months.
The start of the iteration is always aligned to Jan 1 2000.
"""
dt_start = safe_fromtimestamp(start)
dt_end = safe_fromtimestamp(end)
dmonths = (12 * (dt_start.year - 2000) + dt_start.month - 1) % months
dt = _advance_month(dt_start.replace(day=1, hour=0, minute=0, second=0, microsecond=0), -dmonths)
while dt < dt_start:
dt = _advance_month(dt, months)
timestamps = []
while dt <= dt_end:
timestamps.append(dt_to_sec(dt))
dt = _advance_month(dt, months)
return timestamps
def _four_digit_year(t):
""" Round to the nearest Jan 1, roughly.
"""
dt = safe_fromtimestamp(t)
year = dt.year
if dt.month >= 7:
year += 1
return str(year)
def _two_digit_year(t):
""" Round to the nearest Jan 1, roughly.
"""
dt = safe_fromtimestamp(t)
year = dt.year
if dt.month >= 7:
year += 1
return "'%02d" % (year % 100)
def _four_digit_year(t):
""" Round to the nearest Jan 1, roughly.
"""
dt = safe_fromtimestamp(t)
year = dt.year
if dt.month >= 7:
year += 1
return str(year)
def _two_digit_year(t):
""" Round to the nearest Jan 1, roughly.
"""
dt = safe_fromtimestamp(t)
year = dt.year
if dt.month >= 7:
year += 1
return "'%02d" % (year % 100)
def trange_months(start, end, months):
""" Create a range of timestamps separated by a given number of months.
The start of the iteration is always aligned to Jan 1 2000.
"""
dt_start = safe_fromtimestamp(start)
dt_end = safe_fromtimestamp(end)
dmonths = (12 * (dt_start.year - 2000) + dt_start.month - 1) % months
dt = _advance_month(dt_start.replace(day=1, hour=0, minute=0, second=0,
microsecond=0), -dmonths)
while dt < dt_start:
dt = _advance_month(dt, months)
timestamps = []
while dt <= dt_end:
timestamps.append(dt_to_sec(dt))
dt = _advance_month(dt, months)
return timestamps
def trange_years(start, end, years):
""" Create a range of timestamps separated by a given number of years.
The start of the iteration is aligned to Jan 1 2000.
"""
dt_start = safe_fromtimestamp(start)
dt_end = safe_fromtimestamp(end)
dyears = (dt_start.year - 2000) % years
if dyears < 0:
dyears += years
dt = datetime(dt_start.year - dyears, 1, 1, 0, 0, 0, 0)
while dt < dt_start:
dt = _advance_years(dt, years)
timestamps = []
while dt <= dt_end:
timestamps.append(dt_to_sec(dt))
dt = _advance_years(dt, years)
return timestamps
def trange_years(start, end, years):
""" Create a range of timestamps separated by a given number of years.
The start of the iteration is aligned to Jan 1 2000.
"""
dt_start = safe_fromtimestamp(start)
dt_end = safe_fromtimestamp(end)
dyears = (dt_start.year - 2000) % years
if dyears < 0:
dyears += years
dt = datetime(dt_start.year - dyears, 1, 1, 0, 0, 0, 0)
while dt < dt_start:
dt = _advance_years(dt, years)
timestamps = []
while dt <= dt_end:
timestamps.append(dt_to_sec(dt))
dt = _advance_years(dt, years)
return timestamps
def tfrac(t, **time_unit):
""" Performs a calendar-aware split of a time into (aligned_time, frac)
over an interval that is a multiple of one of the following time units:
"microseconds" "milliseconds", "seconds", "minutes", "hours", "days", "years"
Settings of milliseconds..hours are truncated towards 0, days are counted
from January 1st of their respective year, and years are counted from 1 AD.
This may lead to unexpected rounding if multi-day or multi-year intervals
are used.
For example:
If it is currently 4:15pm on January 3rd, 2007, calling:
``tfrac(time.time(), hours=3)``
returns the UNIX number of seconds corresponding to
"January 3rd, 2007 15:00:00"
as the aligned time, and the number of seconds in 1 hour and 15 minutes as
the fractional part.
Parameters
==========
t : float
time in seconds
``**time_unit`` : dict
a single (interval=value) item
Returns
=======
A tuple: (aligned time as UNIX time, remainder in seconds)
"""
unit, period = time_unit.items()[0]
if unit == "milliseconds":
unit = "microsecond"
period *= 1000
else:
unit = unit[:-1] # strip off the 's'
# Find the nearest round date
dt = safe_fromtimestamp(t)
amt = getattr(dt, unit)
ndx = datetime_scale.index(unit)
closest_multiple = int(floor(amt / period) * period)
if closest_multiple == 0 and unit in ("day", "year"):
# TODO: this isn't really quite right for intervals of days > 1...
closest_multiple = 1
whole = dt.replace(**{unit: closest_multiple})
whole = whole.replace(**dict(datetime_zeros[:ndx]))
frac = td_to_sec(dt - whole)
return dt_to_sec(whole), frac
def tfrac(t, **time_unit):
""" Performs a calendar-aware split of a time into (aligned_time, frac)
over an interval that is a multiple of one of the following time units:
"microseconds" "milliseconds", "seconds", "minutes", "hours", "days", "years"
Settings of milliseconds..hours are truncated towards 0, days are counted
from January 1st of their respective year, and years are counted from 1 AD.
This may lead to unexpected rounding if multi-day or multi-year intervals
are used.
For example:
If it is currently 4:15pm on January 3rd, 2007, calling:
``tfrac(time.time(), hours=3)``
returns the UNIX number of seconds corresponding to
"January 3rd, 2007 15:00:00"
as the aligned time, and the number of seconds in 1 hour and 15 minutes as
the fractional part.
Parameters
==========
t : float
time in seconds
``**time_unit`` : dict
a single (interval=value) item
Returns
=======
A tuple: (aligned time as UNIX time, remainder in seconds)
"""
unit, period = time_unit.items()[0]
if unit == "milliseconds":
unit = "microsecond"
period *= 1000
else:
unit = unit[:-1] # strip off the 's'
# Find the nearest round date
dt = safe_fromtimestamp(t)
amt = getattr(dt, unit)
ndx = datetime_scale.index(unit)
closest_multiple = int(floor(amt / period) * period)
if closest_multiple == 0 and unit in ("day", "year"):
# TODO: this isn't really quite right for intervals of days > 1...
closest_multiple = 1
whole = dt.replace(**{unit: closest_multiple})
whole = whole.replace(**dict(datetime_zeros[:ndx]))
frac = td_to_sec(dt - whole)
return dt_to_sec(whole), frac