gh-59648: Nanosecond support for datetime

Lib/datetime.py

@@ -158,13 +158,14 @@ def _build_struct_time(y, m, d, hh, mm, ss, dstflag):
     dnum = _days_before_month(y, m) + d
     return _time.struct_time((y, m, d, hh, mm, ss, wday, dnum, dstflag))
 
-def _format_time(hh, mm, ss, us, timespec='auto'):
+def _format_time(hh, mm, ss, us, sus, timespec='auto'):
     specs = {
         'hours': '{:02d}',
         'minutes': '{:02d}:{:02d}',
         'seconds': '{:02d}:{:02d}:{:02d}',
         'milliseconds': '{:02d}:{:02d}:{:02d}.{:03d}',
-        'microseconds': '{:02d}:{:02d}:{:02d}.{:06d}'
+        'microseconds': '{:02d}:{:02d}:{:02d}.{:06d}',
+        'submicroseconds': '{:02d}:{:02d}:{:02d}.{:06d}{:03d}',
     }
 
     if timespec == 'auto':
@@ -177,7 +178,7 @@ def _format_time(hh, mm, ss, us, timespec='auto'):
     except KeyError:
         raise ValueError('Unknown timespec value')
     else:
-        return fmt.format(hh, mm, ss, us)
+        return fmt.format(hh, mm, ss, us, sus)
 
 def _format_offset(off):
     s = ''
@@ -525,11 +526,12 @@ def _check_date_fields(year, month, day):
         raise ValueError('day must be in 1..%d' % dim, day)
     return year, month, day
 
-def _check_time_fields(hour, minute, second, microsecond, fold):
+def _check_time_fields(hour, minute, second, microsecond, submicrosecond, fold):
     hour = _index(hour)
     minute = _index(minute)
     second = _index(second)
     microsecond = _index(microsecond)
+    submicrosecond = _index(submicrosecond)
     if not 0 <= hour <= 23:
         raise ValueError('hour must be in 0..23', hour)
     if not 0 <= minute <= 59:
@@ -538,9 +540,11 @@ def _check_time_fields(hour, minute, second, microsecond, fold):
         raise ValueError('second must be in 0..59', second)
     if not 0 <= microsecond <= 999999:
         raise ValueError('microsecond must be in 0..999999', microsecond)
+    if not 0 <= submicrosecond <= 999:
+        raise ValueError('Currently submicrosecond must be in 0..999', submicrosecond)
     if fold not in (0, 1):
         raise ValueError('fold must be either 0 or 1', fold)
-    return hour, minute, second, microsecond, fold
+    return hour, minute, second, microsecond, submicrosecond, fold
 
 def _check_tzinfo_arg(tz):
     if tz is not None and not isinstance(tz, tzinfo):
@@ -1274,7 +1278,15 @@ def __reduce__(self):
             args = getinitargs()
         else:
             args = ()
-        return (self.__class__, args, self.__getstate__())
+        getstate = getattr(self, "__getstate__", None)
+        if getstate:
+            state = getstate()
+        else:
+            state = getattr(self, "__dict__", None) or None
+        if state is None:
+            return (self.__class__, args)
+        else:
+            return (self.__class__, args, state)
 
 
 class IsoCalendarDate(tuple):
@@ -1331,9 +1343,9 @@ class time:
     Properties (readonly):
     hour, minute, second, microsecond, tzinfo, fold
     """
-    __slots__ = '_hour', '_minute', '_second', '_microsecond', '_tzinfo', '_hashcode', '_fold'
+    __slots__ = '_hour', '_minute', '_second', '_microsecond', '_submicrosecond', '_tzinfo', '_hashcode', '_fold'
 
-    def __new__(cls, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0):
+    def __new__(cls, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0, submicrosecond=0):
         """Constructor.
 
         Arguments:
@@ -1359,14 +1371,15 @@ def __new__(cls, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold
             self.__setstate(hour, minute or None)
             self._hashcode = -1
             return self
-        hour, minute, second, microsecond, fold = _check_time_fields(
-            hour, minute, second, microsecond, fold)
+        hour, minute, second, microsecond, submicrosecond, fold = _check_time_fields(
+            hour, minute, second, microsecond, submicrosecond, fold)
         _check_tzinfo_arg(tzinfo)
         self = object.__new__(cls)
         self._hour = hour
         self._minute = minute
         self._second = second
         self._microsecond = microsecond
+        self._submicrosecond = submicrosecond
         self._tzinfo = tzinfo
         self._hashcode = -1
         self._fold = fold
@@ -1393,6 +1406,11 @@ def microsecond(self):
         """microsecond (0-999999)"""
         return self._microsecond
 
+    @property
+    def submicrosecond(self):
+        """submicrosecond (0-999)"""
+        return self._submicrosecond
+
     @property
     def tzinfo(self):
         """timezone info object"""
@@ -1480,9 +1498,9 @@ def __hash__(self):
                 assert not m % timedelta(minutes=1), "whole minute"
                 m //= timedelta(minutes=1)
                 if 0 <= h < 24:
-                    self._hashcode = hash(time(h, m, self.second, self.microsecond))
+                    self._hashcode = hash(time(h, m, self.second, self.microsecond, self.submicrosecond))
                 else:
-                    self._hashcode = hash((h, m, self.second, self.microsecond))
+                    self._hashcode = hash((h, m, self.second, self.microsecond, self.submicrosecond))
         return self._hashcode
 
     # Conversion to string
@@ -1522,7 +1540,7 @@ def isoformat(self, timespec='auto'):
         'minutes', 'seconds', 'milliseconds' and 'microseconds'.
         """
         s = _format_time(self._hour, self._minute, self._second,
-                          self._microsecond, timespec)
+                          self._microsecond, self._submicrosecond, timespec)
         tz = self._tzstr()
         if tz:
             s += tz
@@ -1671,7 +1689,7 @@ class datetime(date):
     __slots__ = date.__slots__ + time.__slots__
 
     def __new__(cls, year, month=None, day=None, hour=0, minute=0, second=0,
-                microsecond=0, tzinfo=None, *, fold=0):
+                microsecond=0, tzinfo=None, *, fold=0, submicrosecond=0):
         if (isinstance(year, (bytes, str)) and len(year) == 10 and
             1 <= ord(year[2:3])&0x7F <= 12):
             # Pickle support
@@ -1689,8 +1707,8 @@ def __new__(cls, year, month=None, day=None, hour=0, minute=0, second=0,
             self._hashcode = -1
             return self
         year, month, day = _check_date_fields(year, month, day)
-        hour, minute, second, microsecond, fold = _check_time_fields(
-            hour, minute, second, microsecond, fold)
+        hour, minute, second, microsecond, submicrosecond, fold = _check_time_fields(
+            hour, minute, second, microsecond, submicrosecond, fold)
         _check_tzinfo_arg(tzinfo)
         self = object.__new__(cls)
         self._year = year
@@ -1700,6 +1718,7 @@ def __new__(cls, year, month=None, day=None, hour=0, minute=0, second=0,
         self._minute = minute
         self._second = second
         self._microsecond = microsecond
+        self._submicrosecond = submicrosecond
         self._tzinfo = tzinfo
         self._hashcode = -1
         self._fold = fold
@@ -1741,19 +1760,21 @@ def _fromtimestamp(cls, t, utc, tz):
 
         A timezone info object may be passed in as well.
         """
-        frac, t = _math.modf(t)
-        us = round(frac * 1e6)
-        if us >= 1000000:
-            t += 1
-            us -= 1000000
-        elif us < 0:
-            t -= 1
-            us += 1000000
 
+        # f, a = math.modf(1651815892989527.7)
+        # print(f, a)
+        # 0.75 1651815892989527.0
+        # f = 0.7 -> 0.75 precision broken
+
+        # Decimal is a heavyweight module
+
+        t, dp = str(t).split('.')
+        us, sus = dp[:6], f'{dp[6:9]:0<3}'
+        t, us, sus = int(t), int(us), int(sus)
         converter = _time.gmtime if utc else _time.localtime
         y, m, d, hh, mm, ss, weekday, jday, dst = converter(t)
         ss = min(ss, 59)    # clamp out leap seconds if the platform has them
-        result = cls(y, m, d, hh, mm, ss, us, tz)
+        result = cls(y, m, d, hh, mm, ss, us, tz, submicrosecond=sus)
         if tz is None and not utc:
             # As of version 2015f max fold in IANA database is
             # 23 hours at 1969-09-30 13:00:00 in Kwajalein.
@@ -1768,11 +1789,11 @@ def _fromtimestamp(cls, t, utc, tz):
                 return result
 
             y, m, d, hh, mm, ss = converter(t - max_fold_seconds)[:6]
-            probe1 = cls(y, m, d, hh, mm, ss, us, tz)
+            probe1 = cls(y, m, d, hh, mm, ss, us, tz, submicrosecond=sus)
             trans = result - probe1 - timedelta(0, max_fold_seconds)
             if trans.days < 0:
                 y, m, d, hh, mm, ss = converter(t + trans // timedelta(0, 1))[:6]
-                probe2 = cls(y, m, d, hh, mm, ss, us, tz)
+                probe2 = cls(y, m, d, hh, mm, ss, us, tz, submicrosecond=sus)
                 if probe2 == result:
                     result._fold = 1
         elif tz is not None:
@@ -1797,13 +1818,13 @@ def utcfromtimestamp(cls, t):
     @classmethod
     def now(cls, tz=None):
         "Construct a datetime from time.time() and optional time zone info."
-        t = _time.time()
+        t = _time.time_ns() / 1e9
         return cls.fromtimestamp(t, tz)
 
     @classmethod
     def utcnow(cls):
         "Construct a UTC datetime from time.time()."
-        t = _time.time()
+        t = _time.time_ns() / 1e9
         return cls.utcfromtimestamp(t)
 
     @classmethod
@@ -2020,7 +2041,7 @@ def isoformat(self, sep='T', timespec='auto'):
         """
         s = ("%04d-%02d-%02d%c" % (self._year, self._month, self._day, sep) +
              _format_time(self._hour, self._minute, self._second,
-                          self._microsecond, timespec))
+                          self._microsecond, self._submicrosecond, timespec))
 
         off = self.utcoffset()
         tz = _format_offset(off)
@@ -2612,7 +2633,8 @@ def _name_from_offset(delta):
 # pretty bizarre, and a tzinfo subclass can override fromutc() if it is.
 
 try:
-    from _datetime import *
+    # TODO: temp comment for testing
+    from _datetime2 import *
 except ImportError:
     pass
 else:

Misc/NEWS.d/next/Library/2022-04-30-12-42-43.gh-issue-59648.6tZvYS.rst

@@ -0,0 +1 @@
+Nanosecond support for datetime