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