147 lines
4.6 KiB
Python
147 lines
4.6 KiB
Python
"""Functions to parse datetime objects."""
|
|
|
|
# We're using regular expressions rather than time.strptime because:
|
|
# - They provide both validation and parsing.
|
|
# - They're more flexible for datetimes.
|
|
# - The date/datetime/time constructors produce friendlier error messages.
|
|
|
|
import datetime
|
|
import re
|
|
|
|
from django.utils.timezone import get_fixed_timezone, utc
|
|
|
|
date_re = re.compile(
|
|
r'(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})$'
|
|
)
|
|
|
|
time_re = re.compile(
|
|
r'(?P<hour>\d{1,2}):(?P<minute>\d{1,2})'
|
|
r'(?::(?P<second>\d{1,2})(?:\.(?P<microsecond>\d{1,6})\d{0,6})?)?'
|
|
)
|
|
|
|
datetime_re = re.compile(
|
|
r'(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})'
|
|
r'[T ](?P<hour>\d{1,2}):(?P<minute>\d{1,2})'
|
|
r'(?::(?P<second>\d{1,2})(?:\.(?P<microsecond>\d{1,6})\d{0,6})?)?'
|
|
r'(?P<tzinfo>Z|[+-]\d{2}(?::?\d{2})?)?$'
|
|
)
|
|
|
|
standard_duration_re = re.compile(
|
|
r'^'
|
|
r'(?:(?P<days>-?\d+) (days?, )?)?'
|
|
r'((?:(?P<hours>-?\d+):)(?=\d+:\d+))?'
|
|
r'(?:(?P<minutes>-?\d+):)?'
|
|
r'(?P<seconds>-?\d+)'
|
|
r'(?:\.(?P<microseconds>\d{1,6})\d{0,6})?'
|
|
r'$'
|
|
)
|
|
|
|
# Support the sections of ISO 8601 date representation that are accepted by
|
|
# timedelta
|
|
iso8601_duration_re = re.compile(
|
|
r'^(?P<sign>[-+]?)'
|
|
r'P'
|
|
r'(?:(?P<days>\d+(.\d+)?)D)?'
|
|
r'(?:T'
|
|
r'(?:(?P<hours>\d+(.\d+)?)H)?'
|
|
r'(?:(?P<minutes>\d+(.\d+)?)M)?'
|
|
r'(?:(?P<seconds>\d+(.\d+)?)S)?'
|
|
r')?'
|
|
r'$'
|
|
)
|
|
|
|
# Support PostgreSQL's day-time interval format, e.g. "3 days 04:05:06". The
|
|
# year-month and mixed intervals cannot be converted to a timedelta and thus
|
|
# aren't accepted.
|
|
postgres_interval_re = re.compile(
|
|
r'^'
|
|
r'(?:(?P<days>-?\d+) (days? ?))?'
|
|
r'(?:(?P<sign>[-+])?'
|
|
r'(?P<hours>\d+):'
|
|
r'(?P<minutes>\d\d):'
|
|
r'(?P<seconds>\d\d)'
|
|
r'(?:\.(?P<microseconds>\d{1,6}))?'
|
|
r')?$'
|
|
)
|
|
|
|
|
|
def parse_date(value):
|
|
"""Parse a string and return a datetime.date.
|
|
|
|
Raise ValueError if the input is well formatted but not a valid date.
|
|
Return None if the input isn't well formatted.
|
|
"""
|
|
match = date_re.match(value)
|
|
if match:
|
|
kw = {k: int(v) for k, v in match.groupdict().items()}
|
|
return datetime.date(**kw)
|
|
|
|
|
|
def parse_time(value):
|
|
"""Parse a string and return a datetime.time.
|
|
|
|
This function doesn't support time zone offsets.
|
|
|
|
Raise ValueError if the input is well formatted but not a valid time.
|
|
Return None if the input isn't well formatted, in particular if it
|
|
contains an offset.
|
|
"""
|
|
match = time_re.match(value)
|
|
if match:
|
|
kw = match.groupdict()
|
|
kw['microsecond'] = kw['microsecond'] and kw['microsecond'].ljust(6, '0')
|
|
kw = {k: int(v) for k, v in kw.items() if v is not None}
|
|
return datetime.time(**kw)
|
|
|
|
|
|
def parse_datetime(value):
|
|
"""Parse a string and return a datetime.datetime.
|
|
|
|
This function supports time zone offsets. When the input contains one,
|
|
the output uses a timezone with a fixed offset from UTC.
|
|
|
|
Raise ValueError if the input is well formatted but not a valid datetime.
|
|
Return None if the input isn't well formatted.
|
|
"""
|
|
match = datetime_re.match(value)
|
|
if match:
|
|
kw = match.groupdict()
|
|
kw['microsecond'] = kw['microsecond'] and kw['microsecond'].ljust(6, '0')
|
|
tzinfo = kw.pop('tzinfo')
|
|
if tzinfo == 'Z':
|
|
tzinfo = utc
|
|
elif tzinfo is not None:
|
|
offset_mins = int(tzinfo[-2:]) if len(tzinfo) > 3 else 0
|
|
offset = 60 * int(tzinfo[1:3]) + offset_mins
|
|
if tzinfo[0] == '-':
|
|
offset = -offset
|
|
tzinfo = get_fixed_timezone(offset)
|
|
kw = {k: int(v) for k, v in kw.items() if v is not None}
|
|
kw['tzinfo'] = tzinfo
|
|
return datetime.datetime(**kw)
|
|
|
|
|
|
def parse_duration(value):
|
|
"""Parse a duration string and return a datetime.timedelta.
|
|
|
|
The preferred format for durations in Django is '%d %H:%M:%S.%f'.
|
|
|
|
Also supports ISO 8601 representation and PostgreSQL's day-time interval
|
|
format.
|
|
"""
|
|
match = (
|
|
standard_duration_re.match(value) or
|
|
iso8601_duration_re.match(value) or
|
|
postgres_interval_re.match(value)
|
|
)
|
|
if match:
|
|
kw = match.groupdict()
|
|
days = datetime.timedelta(float(kw.pop('days', 0) or 0))
|
|
sign = -1 if kw.pop('sign', '+') == '-' else 1
|
|
if kw.get('microseconds'):
|
|
kw['microseconds'] = kw['microseconds'].ljust(6, '0')
|
|
if kw.get('seconds') and kw.get('microseconds') and kw['seconds'].startswith('-'):
|
|
kw['microseconds'] = '-' + kw['microseconds']
|
|
kw = {k: float(v) for k, v in kw.items() if v is not None}
|
|
return days + sign * datetime.timedelta(**kw)
|