This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10123

typing: add type annotations to mercurial/utils/dateutil.py
ClosedPublic

Authored by mharbison72 on Mar 6 2021, 7:45 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG15c2f9220ae8: typing: add type annotations to mercurial/utils/dateutil.py
Summary

For now, I'm just typing around the edges to help find issues with TortoiseHg.
If the custom hgdate type is useful elsewhere as I go, I'll move it to a file
dedicated to custom types. I'm not loving the ban on camelcase type names here
that test-check-code.t flagged, but I'm not sure how to disable that even if
everyone agreed that it's a bad idea to go against the normal convention for
types.

While here, fix an issue that pytype found in parsedate when an invalid date
tuple is passed by raising a ProgrammingError instead of crashing. (Tuple
doesn't have a strip attribute.)

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

mharbison72 created this revision.Mar 6 2021, 7:45 PM
mharbison72 added a commit: rHG15c2f9220ae8: typing: add type annotations to mercurial/utils/dateutil.py.Mar 8 2021, 3:25 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG15c2f9220ae8: typing: add type annotations to mercurial/utils/dateutil.py (authored by mharbison72). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 26130

mercurial/utils/dateutil.py

from ..i18n import _ from ..i18n import _
from .. import ( from .. import (
encoding, encoding,
error, error,
pycompat, pycompat,
) )
if pycompat.TYPE_CHECKING:
from typing import (
Callable,
Dict,
Iterable,
Optional,
Tuple,
Union,
)
hgdate = Tuple[float, int] # (unixtime, offset)
# used by parsedate # used by parsedate
defaultdateformats = ( defaultdateformats = (
b'%Y-%m-%dT%H:%M:%S', # the 'real' ISO8601 b'%Y-%m-%dT%H:%M:%S', # the 'real' ISO8601
b'%Y-%m-%dT%H:%M', # without seconds b'%Y-%m-%dT%H:%M', # without seconds
b'%Y-%m-%dT%H%M%S', # another awful but legal variant without : b'%Y-%m-%dT%H%M%S', # another awful but legal variant without :
b'%Y-%m-%dT%H%M', # without seconds b'%Y-%m-%dT%H%M', # without seconds
b'%Y-%m-%d %H:%M:%S', # our common legal variant b'%Y-%m-%d %H:%M:%S', # our common legal variant
b'%Y-%m-%d %H:%M', # without seconds b'%Y-%m-%d %H:%M', # without seconds
b"%Y", b"%Y",
b"%Y-%m", b"%Y-%m",
b"%b", b"%b",
b"%b %Y", b"%b %Y",
) )
def makedate(timestamp=None): def makedate(timestamp=None):
# type: (Optional[float]) -> hgdate
"""Return a unix timestamp (or the current time) as a (unixtime, """Return a unix timestamp (or the current time) as a (unixtime,
offset) tuple based off the local timezone.""" offset) tuple based off the local timezone."""
if timestamp is None: if timestamp is None:
timestamp = time.time() timestamp = time.time()
if timestamp < 0: if timestamp < 0:
hint = _(b"check your clock") hint = _(b"check your clock")
raise error.InputError( raise error.InputError(
_(b"negative timestamp: %d") % timestamp, hint=hint _(b"negative timestamp: %d") % timestamp, hint=hint
) )
delta = datetime.datetime.utcfromtimestamp( delta = datetime.datetime.utcfromtimestamp(
timestamp timestamp
) - datetime.datetime.fromtimestamp(timestamp) ) - datetime.datetime.fromtimestamp(timestamp)
tz = delta.days * 86400 + delta.seconds tz = delta.days * 86400 + delta.seconds
return timestamp, tz return timestamp, tz
def datestr(date=None, format=b'%a %b %d %H:%M:%S %Y %1%2'): def datestr(date=None, format=b'%a %b %d %H:%M:%S %Y %1%2'):
# type: (Optional[hgdate], bytes) -> bytes
"""represent a (unixtime, offset) tuple as a localized time. """represent a (unixtime, offset) tuple as a localized time.
unixtime is seconds since the epoch, and offset is the time zone's unixtime is seconds since the epoch, and offset is the time zone's
number of seconds away from UTC. number of seconds away from UTC.
>>> datestr((0, 0)) >>> datestr((0, 0))
'Thu Jan 01 00:00:00 1970 +0000' 'Thu Jan 01 00:00:00 1970 +0000'
>>> datestr((42, 0)) >>> datestr((42, 0))
'Thu Jan 01 00:00:42 1970 +0000' 'Thu Jan 01 00:00:42 1970 +0000'
# because they use the gmtime() system call which is buggy on Windows # because they use the gmtime() system call which is buggy on Windows
# for negative values. # for negative values.
t = datetime.datetime(1970, 1, 1) + datetime.timedelta(seconds=d) t = datetime.datetime(1970, 1, 1) + datetime.timedelta(seconds=d)
s = encoding.strtolocal(t.strftime(encoding.strfromlocal(format))) s = encoding.strtolocal(t.strftime(encoding.strfromlocal(format)))
return s return s
def shortdate(date=None): def shortdate(date=None):
# type: (Optional[hgdate]) -> bytes
"""turn (timestamp, tzoff) tuple into iso 8631 date.""" """turn (timestamp, tzoff) tuple into iso 8631 date."""
return datestr(date, format=b'%Y-%m-%d') return datestr(date, format=b'%Y-%m-%d')
def parsetimezone(s): def parsetimezone(s):
# type: (bytes) -> Tuple[Optional[int], bytes]
"""find a trailing timezone, if any, in string, and return a """find a trailing timezone, if any, in string, and return a
(offset, remainder) pair""" (offset, remainder) pair"""
s = pycompat.bytestr(s) s = pycompat.bytestr(s)
if s.endswith(b"GMT") or s.endswith(b"UTC"): if s.endswith(b"GMT") or s.endswith(b"UTC"):
return 0, s[:-3].rstrip() return 0, s[:-3].rstrip()
# Unix-style timezones [+-]hhmm # Unix-style timezones [+-]hhmm
hours = int(s[-5:-3]) hours = int(s[-5:-3])
minutes = int(s[-2:]) minutes = int(s[-2:])
return -sign * (hours * 60 + minutes) * 60, s[:-6] return -sign * (hours * 60 + minutes) * 60, s[:-6]
return None, s return None, s
def strdate(string, format, defaults=None): def strdate(string, format, defaults=None):
# type: (bytes, bytes, Optional[Dict[bytes, Tuple[bytes, bytes]]]) -> hgdate
"""parse a localized time string and return a (unixtime, offset) tuple. """parse a localized time string and return a (unixtime, offset) tuple.
if the string cannot be parsed, ValueError is raised.""" if the string cannot be parsed, ValueError is raised."""
if defaults is None: if defaults is None:
defaults = {} defaults = {}
# NOTE: unixtime = localunixtime + offset # NOTE: unixtime = localunixtime + offset
offset, date = parsetimezone(string) offset, date = parsetimezone(string)
unixtime = int(time.mktime(timetuple)) unixtime = int(time.mktime(timetuple))
offset = unixtime - localunixtime offset = unixtime - localunixtime
else: else:
unixtime = localunixtime + offset unixtime = localunixtime + offset
return unixtime, offset return unixtime, offset
def parsedate(date, formats=None, bias=None): def parsedate(date, formats=None, bias=None):
# type: (Union[bytes, hgdate], Optional[Iterable[bytes]], Optional[Dict[bytes, bytes]]) -> hgdate
"""parse a localized date/time and return a (unixtime, offset) tuple. """parse a localized date/time and return a (unixtime, offset) tuple.
The date may be a "unixtime offset" string or in one of the specified The date may be a "unixtime offset" string or in one of the specified
formats. If the date already is a (unixtime, offset) tuple, it is returned. formats. If the date already is a (unixtime, offset) tuple, it is returned.
>>> parsedate(b' today ') == parsedate( >>> parsedate(b' today ') == parsedate(
... datetime.date.today().strftime('%b %d').encode('ascii')) ... datetime.date.today().strftime('%b %d').encode('ascii'))
True True
True True
>>> parsedate(b'2000 UTC', formats=extendeddateformats) >>> parsedate(b'2000 UTC', formats=extendeddateformats)
(946684800, 0) (946684800, 0)
""" """
if bias is None: if bias is None:
bias = {} bias = {}
if not date: if not date:
return 0, 0 return 0, 0
if isinstance(date, tuple) and len(date) == 2: if isinstance(date, tuple):
if len(date) == 2:
return date return date
else:
raise error.ProgrammingError(b"invalid date format")
if not formats: if not formats:
formats = defaultdateformats formats = defaultdateformats
date = date.strip() date = date.strip()
if date == b'now' or date == _(b'now'): if date == b'now' or date == _(b'now'):
return makedate() return makedate()
if date == b'today' or date == _(b'today'): if date == b'today' or date == _(b'today'):
date = datetime.date.today().strftime('%b %d') date = datetime.date.today().strftime('%b %d')
if when < -0x80000000 or when > 0x7FFFFFFF: if when < -0x80000000 or when > 0x7FFFFFFF:
raise error.ParseError(_(b'date exceeds 32 bits: %d') % when) raise error.ParseError(_(b'date exceeds 32 bits: %d') % when)
if offset < -50400 or offset > 43200: if offset < -50400 or offset > 43200:
raise error.ParseError(_(b'impossible time zone offset: %d') % offset) raise error.ParseError(_(b'impossible time zone offset: %d') % offset)
return when, offset return when, offset
def matchdate(date): def matchdate(date):
# type: (bytes) -> Callable[[float], bool]
"""Return a function that matches a given date match specifier """Return a function that matches a given date match specifier
Formats include: Formats include:
'{date}' match a given date to the accuracy provided '{date}' match a given date to the accuracy provided
'<{date}' on or before a given date '<{date}' on or before a given date
True True
>>> f(p4[0]) >>> f(p4[0])
False False
>>> f(p5[0]) >>> f(p5[0])
False False
""" """
def lower(date): def lower(date):
# type: (bytes) -> float
d = {b'mb': b"1", b'd': b"1"} d = {b'mb': b"1", b'd': b"1"}
return parsedate(date, extendeddateformats, d)[0] return parsedate(date, extendeddateformats, d)[0]
def upper(date): def upper(date):
# type: (bytes) -> float
d = {b'mb': b"12", b'HI': b"23", b'M': b"59", b'S': b"59"} d = {b'mb': b"12", b'HI': b"23", b'M': b"59", b'S': b"59"}
for days in (b"31", b"30", b"29"): for days in (b"31", b"30", b"29"):
try: try:
d[b"d"] = days d[b"d"] = days
return parsedate(date, extendeddateformats, d)[0] return parsedate(date, extendeddateformats, d)[0]
except error.ParseError: except error.ParseError:
pass pass
d[b"d"] = b"28" d[b"d"] = b"28"