add nanosecond

Author: SmartManoj

Lib/_pydatetime.py

@@ -161,13 +161,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':
@@ -180,7 +181,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, sep=':'):
     s = ''
@@ -578,11 +579,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:
@@ -591,9 +593,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):
@@ -1350,7 +1354,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)
+        if state is None:
+            return (self.__class__, args)
+        else:
+            return (self.__class__, args, state)
 
 
 class IsoCalendarDate(tuple):
@@ -1408,9 +1420,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:
@@ -1436,14 +1448,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
@@ -1476,6 +1489,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"""
@@ -1563,9 +1581,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
@@ -1605,7 +1623,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
@@ -1755,7 +1773,7 @@ class datetime(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
@@ -1773,8 +1791,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
@@ -1784,6 +1802,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
@@ -1825,19 +1844,13 @@ 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
 
+        t = str(t)
+        t, us, sus = map(int, [t[:-9], t[-9:-3], t[-3:]])
         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.
@@ -1852,11 +1865,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:
@@ -1888,7 +1901,7 @@ 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()
         return cls.fromtimestamp(t, tz)
 
     @classmethod
@@ -1901,7 +1914,7 @@ def utcnow(cls):
                       "datetime.datetime.now(datetime.UTC).",
                       DeprecationWarning,
                       stacklevel=2)
-        t = _time.time()
+        t = _time.time_ns()
         return cls._fromtimestamp(t, True, None)
 
     @classmethod
@@ -2142,7 +2155,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)