mirror of
https://github.com/rembo10/headphones.git
synced 2026-07-20 07:54:01 +01:00
Initial python3 changes
Mostly just updating libraries, removing string encoding/decoding, fixing some edge cases. No new functionality was added in this commit.
This commit is contained in:
rembo10
@@ -0,0 +1,682 @@
|
||||
"Objects and routines pertaining to date and time (tempora)"
|
||||
|
||||
import datetime
|
||||
import time
|
||||
import re
|
||||
import numbers
|
||||
import functools
|
||||
import warnings
|
||||
import contextlib
|
||||
|
||||
from jaraco.functools import once
|
||||
|
||||
|
||||
class Parser:
|
||||
"""
|
||||
*deprecated*
|
||||
|
||||
Datetime parser: parses a date-time string using multiple possible
|
||||
formats.
|
||||
|
||||
>>> p = Parser(('%H%M', '%H:%M'))
|
||||
>>> tuple(p.parse('1319'))
|
||||
(1900, 1, 1, 13, 19, 0, 0, 1, -1)
|
||||
>>> dateParser = Parser(('%m/%d/%Y', '%Y-%m-%d', '%d-%b-%Y'))
|
||||
>>> tuple(dateParser.parse('2003-12-20'))
|
||||
(2003, 12, 20, 0, 0, 0, 5, 354, -1)
|
||||
>>> tuple(dateParser.parse('16-Dec-1994'))
|
||||
(1994, 12, 16, 0, 0, 0, 4, 350, -1)
|
||||
>>> tuple(dateParser.parse('5/19/2003'))
|
||||
(2003, 5, 19, 0, 0, 0, 0, 139, -1)
|
||||
>>> dtParser = Parser(('%Y-%m-%d %H:%M:%S', '%a %b %d %H:%M:%S %Y'))
|
||||
>>> tuple(dtParser.parse('2003-12-20 19:13:26'))
|
||||
(2003, 12, 20, 19, 13, 26, 5, 354, -1)
|
||||
>>> tuple(dtParser.parse('Tue Jan 20 16:19:33 2004'))
|
||||
(2004, 1, 20, 16, 19, 33, 1, 20, -1)
|
||||
|
||||
Be forewarned, a ValueError will be raised if more than one format
|
||||
matches:
|
||||
|
||||
>>> Parser(('%H%M', '%H%M%S')).parse('732')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
ValueError: More than one format string matched target 732.
|
||||
|
||||
>>> Parser(('%H',)).parse('22:21')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
ValueError: No format strings matched the target 22:21.
|
||||
"""
|
||||
|
||||
formats = ('%m/%d/%Y', '%m/%d/%y', '%Y-%m-%d', '%d-%b-%Y', '%d-%b-%y')
|
||||
"some common default formats"
|
||||
|
||||
def __init__(self, formats=None):
|
||||
warnings.warn("Use dateutil.parser", DeprecationWarning)
|
||||
if formats:
|
||||
self.formats = formats
|
||||
|
||||
def parse(self, target):
|
||||
self.target = target
|
||||
results = tuple(filter(None, map(self._parse, self.formats)))
|
||||
del self.target
|
||||
if not results:
|
||||
tmpl = "No format strings matched the target {target}."
|
||||
raise ValueError(tmpl.format(**locals()))
|
||||
if not len(results) == 1:
|
||||
tmpl = "More than one format string matched target {target}."
|
||||
raise ValueError(tmpl.format(**locals()))
|
||||
return results[0]
|
||||
|
||||
def _parse(self, format):
|
||||
try:
|
||||
result = time.strptime(self.target, format)
|
||||
except ValueError:
|
||||
result = False
|
||||
return result
|
||||
|
||||
|
||||
# some useful constants
|
||||
osc_per_year = 290091329207984000
|
||||
"""
|
||||
mean vernal equinox year expressed in oscillations of atomic cesium at the
|
||||
year 2000 (see http://webexhibits.org/calendars/timeline.html for more info).
|
||||
"""
|
||||
osc_per_second = 9192631770
|
||||
seconds_per_second = 1
|
||||
seconds_per_year = 31556940
|
||||
seconds_per_minute = 60
|
||||
minutes_per_hour = 60
|
||||
hours_per_day = 24
|
||||
seconds_per_hour = seconds_per_minute * minutes_per_hour
|
||||
seconds_per_day = seconds_per_hour * hours_per_day
|
||||
days_per_year = seconds_per_year / seconds_per_day
|
||||
thirty_days = datetime.timedelta(days=30)
|
||||
# these values provide useful averages
|
||||
six_months = datetime.timedelta(days=days_per_year / 2)
|
||||
seconds_per_month = seconds_per_year / 12
|
||||
hours_per_month = hours_per_day * days_per_year / 12
|
||||
|
||||
|
||||
@once
|
||||
def _needs_year_help():
|
||||
"""
|
||||
Some versions of Python render %Y with only three characters :(
|
||||
https://bugs.python.org/issue39103
|
||||
"""
|
||||
return len(datetime.date(900, 1, 1).strftime('%Y')) != 4
|
||||
|
||||
|
||||
def ensure_datetime(ob):
|
||||
"""
|
||||
Given a datetime or date or time object from the ``datetime``
|
||||
module, always return a datetime using default values.
|
||||
"""
|
||||
if isinstance(ob, datetime.datetime):
|
||||
return ob
|
||||
date = time = ob
|
||||
if isinstance(ob, datetime.date):
|
||||
time = datetime.time()
|
||||
if isinstance(ob, datetime.time):
|
||||
date = datetime.date(1900, 1, 1)
|
||||
return datetime.datetime.combine(date, time)
|
||||
|
||||
|
||||
def strftime(fmt, t):
|
||||
"""
|
||||
Portable strftime.
|
||||
|
||||
In the stdlib, strftime has `known portability problems
|
||||
<https://bugs.python.org/issue13305>`_. This function
|
||||
aims to smooth over those issues and provide a
|
||||
consistent experience across the major platforms.
|
||||
|
||||
>>> strftime('%Y', datetime.datetime(1890, 1, 1))
|
||||
'1890'
|
||||
>>> strftime('%Y', datetime.datetime(900, 1, 1))
|
||||
'0900'
|
||||
|
||||
Supports time.struct_time, tuples, and datetime.datetime objects.
|
||||
|
||||
>>> strftime('%Y-%m-%d', (1976, 5, 7))
|
||||
'1976-05-07'
|
||||
|
||||
Also supports date objects
|
||||
|
||||
>>> strftime('%Y', datetime.date(1976, 5, 7))
|
||||
'1976'
|
||||
|
||||
Also supports milliseconds using %s.
|
||||
|
||||
>>> strftime('%s', datetime.time(microsecond=20000))
|
||||
'020'
|
||||
|
||||
Also supports microseconds (3 digits) using %µ
|
||||
|
||||
>>> strftime('%µ', datetime.time(microsecond=123456))
|
||||
'456'
|
||||
|
||||
Historically, %u was used for microseconds, but now
|
||||
it honors the value rendered by stdlib.
|
||||
|
||||
>>> strftime('%u', datetime.date(1976, 5, 7))
|
||||
'5'
|
||||
|
||||
Also supports microseconds (6 digits) using %f
|
||||
|
||||
>>> strftime('%f', datetime.time(microsecond=23456))
|
||||
'023456'
|
||||
|
||||
Even supports time values on date objects (discouraged):
|
||||
|
||||
>>> strftime('%f', datetime.date(1976, 1, 1))
|
||||
'000000'
|
||||
>>> strftime('%µ', datetime.date(1976, 1, 1))
|
||||
'000'
|
||||
>>> strftime('%s', datetime.date(1976, 1, 1))
|
||||
'000'
|
||||
|
||||
And vice-versa:
|
||||
|
||||
>>> strftime('%Y', datetime.time())
|
||||
'1900'
|
||||
"""
|
||||
if isinstance(t, (time.struct_time, tuple)):
|
||||
t = datetime.datetime(*t[:6])
|
||||
t = ensure_datetime(t)
|
||||
subs = (
|
||||
('%s', '%03d' % (t.microsecond // 1000)),
|
||||
('%µ', '%03d' % (t.microsecond % 1000)),
|
||||
)
|
||||
if _needs_year_help(): # pragma: nocover
|
||||
subs += (('%Y', '%04d' % t.year),)
|
||||
|
||||
def doSub(s, sub):
|
||||
return s.replace(*sub)
|
||||
|
||||
def doSubs(s):
|
||||
return functools.reduce(doSub, subs, s)
|
||||
|
||||
fmt = '%%'.join(map(doSubs, fmt.split('%%')))
|
||||
return t.strftime(fmt)
|
||||
|
||||
|
||||
def datetime_mod(dt, period, start=None):
|
||||
"""
|
||||
Find the time which is the specified date/time truncated to the time delta
|
||||
relative to the start date/time.
|
||||
By default, the start time is midnight of the same day as the specified
|
||||
date/time.
|
||||
|
||||
>>> datetime_mod(datetime.datetime(2004, 1, 2, 3),
|
||||
... datetime.timedelta(days = 1.5),
|
||||
... start = datetime.datetime(2004, 1, 1))
|
||||
datetime.datetime(2004, 1, 1, 0, 0)
|
||||
>>> datetime_mod(datetime.datetime(2004, 1, 2, 13),
|
||||
... datetime.timedelta(days = 1.5),
|
||||
... start = datetime.datetime(2004, 1, 1))
|
||||
datetime.datetime(2004, 1, 2, 12, 0)
|
||||
>>> datetime_mod(datetime.datetime(2004, 1, 2, 13),
|
||||
... datetime.timedelta(days = 7),
|
||||
... start = datetime.datetime(2004, 1, 1))
|
||||
datetime.datetime(2004, 1, 1, 0, 0)
|
||||
>>> datetime_mod(datetime.datetime(2004, 1, 10, 13),
|
||||
... datetime.timedelta(days = 7),
|
||||
... start = datetime.datetime(2004, 1, 1))
|
||||
datetime.datetime(2004, 1, 8, 0, 0)
|
||||
"""
|
||||
if start is None:
|
||||
# use midnight of the same day
|
||||
start = datetime.datetime.combine(dt.date(), datetime.time())
|
||||
# calculate the difference between the specified time and the start date.
|
||||
delta = dt - start
|
||||
|
||||
# now aggregate the delta and the period into microseconds
|
||||
# Use microseconds because that's the highest precision of these time
|
||||
# pieces. Also, using microseconds ensures perfect precision (no floating
|
||||
# point errors).
|
||||
def get_time_delta_microseconds(td):
|
||||
return (td.days * seconds_per_day + td.seconds) * 1000000 + td.microseconds
|
||||
|
||||
delta, period = map(get_time_delta_microseconds, (delta, period))
|
||||
offset = datetime.timedelta(microseconds=delta % period)
|
||||
# the result is the original specified time minus the offset
|
||||
result = dt - offset
|
||||
return result
|
||||
|
||||
|
||||
def datetime_round(dt, period, start=None):
|
||||
"""
|
||||
Find the nearest even period for the specified date/time.
|
||||
|
||||
>>> datetime_round(datetime.datetime(2004, 11, 13, 8, 11, 13),
|
||||
... datetime.timedelta(hours = 1))
|
||||
datetime.datetime(2004, 11, 13, 8, 0)
|
||||
>>> datetime_round(datetime.datetime(2004, 11, 13, 8, 31, 13),
|
||||
... datetime.timedelta(hours = 1))
|
||||
datetime.datetime(2004, 11, 13, 9, 0)
|
||||
>>> datetime_round(datetime.datetime(2004, 11, 13, 8, 30),
|
||||
... datetime.timedelta(hours = 1))
|
||||
datetime.datetime(2004, 11, 13, 9, 0)
|
||||
"""
|
||||
result = datetime_mod(dt, period, start)
|
||||
if abs(dt - result) >= period // 2:
|
||||
result += period
|
||||
return result
|
||||
|
||||
|
||||
def get_nearest_year_for_day(day):
|
||||
"""
|
||||
Returns the nearest year to now inferred from a Julian date.
|
||||
|
||||
>>> freezer = getfixture('freezer')
|
||||
>>> freezer.move_to('2019-05-20')
|
||||
>>> get_nearest_year_for_day(20)
|
||||
2019
|
||||
>>> get_nearest_year_for_day(340)
|
||||
2018
|
||||
>>> freezer.move_to('2019-12-15')
|
||||
>>> get_nearest_year_for_day(20)
|
||||
2020
|
||||
"""
|
||||
now = time.gmtime()
|
||||
result = now.tm_year
|
||||
# if the day is far greater than today, it must be from last year
|
||||
if day - now.tm_yday > 365 // 2:
|
||||
result -= 1
|
||||
# if the day is far less than today, it must be for next year.
|
||||
if now.tm_yday - day > 365 // 2:
|
||||
result += 1
|
||||
return result
|
||||
|
||||
|
||||
def gregorian_date(year, julian_day):
|
||||
"""
|
||||
Gregorian Date is defined as a year and a julian day (1-based
|
||||
index into the days of the year).
|
||||
|
||||
>>> gregorian_date(2007, 15)
|
||||
datetime.date(2007, 1, 15)
|
||||
"""
|
||||
result = datetime.date(year, 1, 1)
|
||||
result += datetime.timedelta(days=julian_day - 1)
|
||||
return result
|
||||
|
||||
|
||||
def get_period_seconds(period):
|
||||
"""
|
||||
return the number of seconds in the specified period
|
||||
|
||||
>>> get_period_seconds('day')
|
||||
86400
|
||||
>>> get_period_seconds(86400)
|
||||
86400
|
||||
>>> get_period_seconds(datetime.timedelta(hours=24))
|
||||
86400
|
||||
>>> get_period_seconds('day + os.system("rm -Rf *")')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
ValueError: period not in (second, minute, hour, day, month, year)
|
||||
"""
|
||||
if isinstance(period, str):
|
||||
try:
|
||||
name = 'seconds_per_' + period.lower()
|
||||
result = globals()[name]
|
||||
except KeyError:
|
||||
msg = "period not in (second, minute, hour, day, month, year)"
|
||||
raise ValueError(msg)
|
||||
elif isinstance(period, numbers.Number):
|
||||
result = period
|
||||
elif isinstance(period, datetime.timedelta):
|
||||
result = period.days * get_period_seconds('day') + period.seconds
|
||||
else:
|
||||
raise TypeError('period must be a string or integer')
|
||||
return result
|
||||
|
||||
|
||||
def get_date_format_string(period):
|
||||
"""
|
||||
For a given period (e.g. 'month', 'day', or some numeric interval
|
||||
such as 3600 (in secs)), return the format string that can be
|
||||
used with strftime to format that time to specify the times
|
||||
across that interval, but no more detailed.
|
||||
For example,
|
||||
|
||||
>>> get_date_format_string('month')
|
||||
'%Y-%m'
|
||||
>>> get_date_format_string(3600)
|
||||
'%Y-%m-%d %H'
|
||||
>>> get_date_format_string('hour')
|
||||
'%Y-%m-%d %H'
|
||||
>>> get_date_format_string(None)
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
TypeError: period must be a string or integer
|
||||
>>> get_date_format_string('garbage')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
ValueError: period not in (second, minute, hour, day, month, year)
|
||||
"""
|
||||
# handle the special case of 'month' which doesn't have
|
||||
# a static interval in seconds
|
||||
if isinstance(period, str) and period.lower() == 'month':
|
||||
return '%Y-%m'
|
||||
file_period_secs = get_period_seconds(period)
|
||||
format_pieces = ('%Y', '-%m-%d', ' %H', '-%M', '-%S')
|
||||
seconds_per_second = 1
|
||||
intervals = (
|
||||
seconds_per_year,
|
||||
seconds_per_day,
|
||||
seconds_per_hour,
|
||||
seconds_per_minute,
|
||||
seconds_per_second,
|
||||
)
|
||||
mods = list(map(lambda interval: file_period_secs % interval, intervals))
|
||||
format_pieces = format_pieces[: mods.index(0) + 1]
|
||||
return ''.join(format_pieces)
|
||||
|
||||
|
||||
def divide_timedelta_float(td, divisor):
|
||||
"""
|
||||
Divide a timedelta by a float value
|
||||
|
||||
>>> one_day = datetime.timedelta(days=1)
|
||||
>>> half_day = datetime.timedelta(days=.5)
|
||||
>>> divide_timedelta_float(one_day, 2.0) == half_day
|
||||
True
|
||||
>>> divide_timedelta_float(one_day, 2) == half_day
|
||||
True
|
||||
"""
|
||||
warnings.warn("Use native division", DeprecationWarning)
|
||||
return td / divisor
|
||||
|
||||
|
||||
def calculate_prorated_values():
|
||||
"""
|
||||
>>> monkeypatch = getfixture('monkeypatch')
|
||||
>>> import builtins
|
||||
>>> monkeypatch.setattr(builtins, 'input', lambda prompt: '3/hour')
|
||||
>>> calculate_prorated_values()
|
||||
per minute: 0.05
|
||||
per hour: 3.0
|
||||
per day: 72.0
|
||||
per month: 2191.454166666667
|
||||
per year: 26297.45
|
||||
"""
|
||||
rate = input("Enter the rate (3/hour, 50/month)> ")
|
||||
for period, value in _prorated_values(rate):
|
||||
print("per {period}: {value}".format(**locals()))
|
||||
|
||||
|
||||
def _prorated_values(rate):
|
||||
"""
|
||||
Given a rate (a string in units per unit time), and return that same
|
||||
rate for various time periods.
|
||||
|
||||
>>> for period, value in _prorated_values('20/hour'):
|
||||
... print('{period}: {value:0.3f}'.format(**locals()))
|
||||
minute: 0.333
|
||||
hour: 20.000
|
||||
day: 480.000
|
||||
month: 14609.694
|
||||
year: 175316.333
|
||||
|
||||
"""
|
||||
res = re.match(r'(?P<value>[\d.]+)/(?P<period>\w+)$', rate).groupdict()
|
||||
value = float(res['value'])
|
||||
value_per_second = value / get_period_seconds(res['period'])
|
||||
for period in ('minute', 'hour', 'day', 'month', 'year'):
|
||||
period_value = value_per_second * get_period_seconds(period)
|
||||
yield period, period_value
|
||||
|
||||
|
||||
def parse_timedelta(str):
|
||||
"""
|
||||
Take a string representing a span of time and parse it to a time delta.
|
||||
Accepts any string of comma-separated numbers each with a unit indicator.
|
||||
|
||||
>>> parse_timedelta('1 day')
|
||||
datetime.timedelta(days=1)
|
||||
|
||||
>>> parse_timedelta('1 day, 30 seconds')
|
||||
datetime.timedelta(days=1, seconds=30)
|
||||
|
||||
>>> parse_timedelta('47.32 days, 20 minutes, 15.4 milliseconds')
|
||||
datetime.timedelta(days=47, seconds=28848, microseconds=15400)
|
||||
|
||||
Supports weeks, months, years
|
||||
|
||||
>>> parse_timedelta('1 week')
|
||||
datetime.timedelta(days=7)
|
||||
|
||||
>>> parse_timedelta('1 year, 1 month')
|
||||
datetime.timedelta(days=395, seconds=58685)
|
||||
|
||||
Note that months and years strict intervals, not aligned
|
||||
to a calendar:
|
||||
|
||||
>>> now = datetime.datetime.now()
|
||||
>>> later = now + parse_timedelta('1 year')
|
||||
>>> diff = later.replace(year=now.year) - now
|
||||
>>> diff.seconds
|
||||
20940
|
||||
|
||||
>>> parse_timedelta('14 seconds foo')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
ValueError: Unexpected 'foo'
|
||||
|
||||
Supports abbreviations:
|
||||
|
||||
>>> parse_timedelta('1s')
|
||||
datetime.timedelta(seconds=1)
|
||||
|
||||
>>> parse_timedelta('1sec')
|
||||
datetime.timedelta(seconds=1)
|
||||
|
||||
>>> parse_timedelta('5min1sec')
|
||||
datetime.timedelta(seconds=301)
|
||||
|
||||
>>> parse_timedelta('1 ms')
|
||||
datetime.timedelta(microseconds=1000)
|
||||
|
||||
>>> parse_timedelta('1 µs')
|
||||
datetime.timedelta(microseconds=1)
|
||||
|
||||
>>> parse_timedelta('1 us')
|
||||
datetime.timedelta(microseconds=1)
|
||||
|
||||
And supports the common colon-separated duration:
|
||||
|
||||
>>> parse_timedelta('14:00:35.362')
|
||||
datetime.timedelta(seconds=50435, microseconds=362000)
|
||||
|
||||
TODO: Should this be 14 hours or 14 minutes?
|
||||
|
||||
>>> parse_timedelta('14:00')
|
||||
datetime.timedelta(seconds=50400)
|
||||
|
||||
>>> parse_timedelta('14:00 minutes')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
ValueError: Cannot specify units with composite delta
|
||||
|
||||
Nanoseconds get rounded to the nearest microsecond:
|
||||
|
||||
>>> parse_timedelta('600 ns')
|
||||
datetime.timedelta(microseconds=1)
|
||||
|
||||
>>> parse_timedelta('.002 µs, 499 ns')
|
||||
datetime.timedelta(microseconds=1)
|
||||
"""
|
||||
return _parse_timedelta_nanos(str).resolve()
|
||||
|
||||
|
||||
def _parse_timedelta_nanos(str):
|
||||
parts = re.finditer(r'(?P<value>[\d.:]+)\s?(?P<unit>[^\W\d_]+)?', str)
|
||||
chk_parts = _check_unmatched(parts, str)
|
||||
deltas = map(_parse_timedelta_part, chk_parts)
|
||||
return sum(deltas, _Saved_NS())
|
||||
|
||||
|
||||
def _check_unmatched(matches, text):
|
||||
"""
|
||||
Ensure no words appear in unmatched text.
|
||||
"""
|
||||
|
||||
def check_unmatched(unmatched):
|
||||
found = re.search(r'\w+', unmatched)
|
||||
if found:
|
||||
raise ValueError(f"Unexpected {found.group(0)!r}")
|
||||
|
||||
pos = 0
|
||||
for match in matches:
|
||||
check_unmatched(text[pos : match.start()])
|
||||
yield match
|
||||
pos = match.end()
|
||||
check_unmatched(text[match.end() :])
|
||||
|
||||
|
||||
_unit_lookup = {
|
||||
'µs': 'microsecond',
|
||||
'µsec': 'microsecond',
|
||||
'us': 'microsecond',
|
||||
'usec': 'microsecond',
|
||||
'micros': 'microsecond',
|
||||
'ms': 'millisecond',
|
||||
'msec': 'millisecond',
|
||||
'millis': 'millisecond',
|
||||
's': 'second',
|
||||
'sec': 'second',
|
||||
'h': 'hour',
|
||||
'hr': 'hour',
|
||||
'm': 'minute',
|
||||
'min': 'minute',
|
||||
'w': 'week',
|
||||
'wk': 'week',
|
||||
'd': 'day',
|
||||
'ns': 'nanosecond',
|
||||
'nsec': 'nanosecond',
|
||||
'nanos': 'nanosecond',
|
||||
}
|
||||
|
||||
|
||||
def _resolve_unit(raw_match):
|
||||
if raw_match is None:
|
||||
return 'second'
|
||||
text = raw_match.lower()
|
||||
return _unit_lookup.get(text, text)
|
||||
|
||||
|
||||
def _parse_timedelta_composite(raw_value, unit):
|
||||
if unit != 'seconds':
|
||||
raise ValueError("Cannot specify units with composite delta")
|
||||
values = raw_value.split(':')
|
||||
units = 'hours', 'minutes', 'seconds'
|
||||
composed = ' '.join(f'{value} {unit}' for value, unit in zip(values, units))
|
||||
return _parse_timedelta_nanos(composed)
|
||||
|
||||
|
||||
def _parse_timedelta_part(match):
|
||||
unit = _resolve_unit(match.group('unit'))
|
||||
if not unit.endswith('s'):
|
||||
unit += 's'
|
||||
raw_value = match.group('value')
|
||||
if ':' in raw_value:
|
||||
return _parse_timedelta_composite(raw_value, unit)
|
||||
value = float(raw_value)
|
||||
if unit == 'months':
|
||||
unit = 'years'
|
||||
value = value / 12
|
||||
if unit == 'years':
|
||||
unit = 'days'
|
||||
value = value * days_per_year
|
||||
return _Saved_NS.derive(unit, value)
|
||||
|
||||
|
||||
class _Saved_NS:
|
||||
"""
|
||||
Bundle a timedelta with nanoseconds.
|
||||
|
||||
>>> _Saved_NS.derive('microseconds', .001)
|
||||
_Saved_NS(td=datetime.timedelta(0), nanoseconds=1)
|
||||
"""
|
||||
|
||||
td = datetime.timedelta()
|
||||
nanoseconds = 0
|
||||
multiplier = dict(
|
||||
seconds=1000000000,
|
||||
milliseconds=1000000,
|
||||
microseconds=1000,
|
||||
)
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
vars(self).update(kwargs)
|
||||
|
||||
@classmethod
|
||||
def derive(cls, unit, value):
|
||||
if unit == 'nanoseconds':
|
||||
return _Saved_NS(nanoseconds=value)
|
||||
|
||||
res = _Saved_NS(td=datetime.timedelta(**{unit: value}))
|
||||
with contextlib.suppress(KeyError):
|
||||
res.nanoseconds = int(value * cls.multiplier[unit]) % 1000
|
||||
return res
|
||||
|
||||
def __add__(self, other):
|
||||
return _Saved_NS(
|
||||
td=self.td + other.td, nanoseconds=self.nanoseconds + other.nanoseconds
|
||||
)
|
||||
|
||||
def resolve(self):
|
||||
"""
|
||||
Resolve any nanoseconds into the microseconds field,
|
||||
discarding any nanosecond resolution (but honoring partial
|
||||
microseconds).
|
||||
"""
|
||||
addl_micros = round(self.nanoseconds / 1000)
|
||||
return self.td + datetime.timedelta(microseconds=addl_micros)
|
||||
|
||||
def __repr__(self):
|
||||
return f'_Saved_NS(td={self.td!r}, nanoseconds={self.nanoseconds!r})'
|
||||
|
||||
|
||||
def divide_timedelta(td1, td2):
|
||||
"""
|
||||
Get the ratio of two timedeltas
|
||||
|
||||
>>> one_day = datetime.timedelta(days=1)
|
||||
>>> one_hour = datetime.timedelta(hours=1)
|
||||
>>> divide_timedelta(one_hour, one_day) == 1 / 24
|
||||
True
|
||||
"""
|
||||
warnings.warn("Use native division", DeprecationWarning)
|
||||
return td1 / td2
|
||||
|
||||
|
||||
def date_range(start=None, stop=None, step=None):
|
||||
"""
|
||||
Much like the built-in function range, but works with dates
|
||||
|
||||
>>> range_items = date_range(
|
||||
... datetime.datetime(2005,12,21),
|
||||
... datetime.datetime(2005,12,25),
|
||||
... )
|
||||
>>> my_range = tuple(range_items)
|
||||
>>> datetime.datetime(2005,12,21) in my_range
|
||||
True
|
||||
>>> datetime.datetime(2005,12,22) in my_range
|
||||
True
|
||||
>>> datetime.datetime(2005,12,25) in my_range
|
||||
False
|
||||
>>> from_now = date_range(stop=datetime.datetime(2099, 12, 31))
|
||||
>>> next(from_now)
|
||||
datetime.datetime(...)
|
||||
"""
|
||||
if step is None:
|
||||
step = datetime.timedelta(days=1)
|
||||
if start is None:
|
||||
start = datetime.datetime.now()
|
||||
while start < stop:
|
||||
yield start
|
||||
start += step
|
||||
Reference in New Issue
Block a user