ENH: Allow Timestamp to accept Nanosecond argument

Add additional test

Add gh issue number in test

Author: mroeschke

doc/source/whatsnew/v0.23.0.txt

@@ -577,6 +577,7 @@ Datetimelike API Changes
 - Operations between a :class:`Series` with dtype ``dtype='datetime64[ns]'`` and a :class:`PeriodIndex` will correctly raises ``TypeError`` (:issue:`18850`)
 - Subtraction of :class:`Series` with timezone-aware ``dtype='datetime64[ns]'`` with mis-matched timezones will raise ``TypeError`` instead of ``ValueError`` (:issue:`18817`)
 - :func:`pandas.merge` provides a more informative error message when trying to merge on timezone-aware and timezone-naive columns (:issue:`15800`)
+- :class:`Timestamp` constructor now accepts a `nanosecond` keyword or positional argument (:issue:`18898`)
 
 .. _whatsnew_0230.api.other:
 

pandas/_libs/tslibs/conversion.pxd

@@ -16,7 +16,8 @@ cdef class _TSObject:
 
 
 cdef convert_to_tsobject(object ts, object tz, object unit,
-                         bint dayfirst, bint yearfirst)
+                         bint dayfirst, bint yearfirst,
+                         int32_t nanos=*)
 
 cdef _TSObject convert_datetime_to_tsobject(datetime ts, object tz,
                                             int32_t nanos=*)

pandas/_libs/tslibs/conversion.pyx

@@ -252,7 +252,7 @@ cpdef int64_t pydt_to_i8(object pydt) except? -1:
 
 
 cdef convert_to_tsobject(object ts, object tz, object unit,
-                         bint dayfirst, bint yearfirst):
+                         bint dayfirst, bint yearfirst, int32_t nanos=0):
     """
     Extract datetime and int64 from any of:
         - np.int64 (with unit providing a possible modifier)
@@ -297,11 +297,11 @@ cdef convert_to_tsobject(object ts, object tz, object unit,
             obj.value = ts
             dt64_to_dtstruct(ts, &obj.dts)
     elif PyDateTime_Check(ts):
-        return convert_datetime_to_tsobject(ts, tz)
+        return convert_datetime_to_tsobject(ts, tz, nanos)
     elif PyDate_Check(ts):
         # Keep the converter same as PyDateTime's
         ts = datetime.combine(ts, datetime_time())
-        return convert_datetime_to_tsobject(ts, tz)
+        return convert_datetime_to_tsobject(ts, tz, nanos)
     elif getattr(ts, '_typ', None) == 'period':
         raise ValueError("Cannot convert Period to Timestamp "
                          "unambiguously. Use to_timestamp")

pandas/_libs/tslibs/timestamps.pyx

@@ -423,7 +423,7 @@ class Timestamp(_Timestamp):
         example, 's' means seconds and 'ms' means milliseconds.
     year, month, day : int
         .. versionadded:: 0.19.0
-    hour, minute, second, microsecond : int, optional, default 0
+    hour, minute, second, microsecond, nanosecond : int, optional, default 0
         .. versionadded:: 0.19.0
     tzinfo : datetime.tzinfo, optional, default None
         .. versionadded:: 0.19.0
@@ -556,7 +556,7 @@ class Timestamp(_Timestamp):
                 object freq=None, tz=None, unit=None,
                 year=None, month=None, day=None,
                 hour=None, minute=None, second=None, microsecond=None,
-                tzinfo=None):
+                tzinfo=None, nanosecond=None):
         # The parameter list folds together legacy parameter names (the first
         # four) and positional and keyword parameter names from pydatetime.
         #
@@ -596,20 +596,20 @@ class Timestamp(_Timestamp):
             return Timestamp(datetime(year, month, day, hour or 0,
                                       minute or 0, second or 0,
                                       microsecond or 0, tzinfo),
-                             tz=tz)
+                             nanosecond=nanosecond, tz=tz)
         elif is_integer_object(freq):
             # User passed positional arguments:
             # Timestamp(year, month, day[, hour[, minute[, second[,
             # microsecond[, tzinfo]]]]])
             return Timestamp(datetime(ts_input, freq, tz, unit or 0,
                                       year or 0, month or 0, day or 0,
-                                      hour), tz=hour)
+                                      hour), nanosecond=minute, tz=hour)
 
         if tzinfo is not None:
             # User passed tzinfo instead of tz; avoid silently ignoring
             tz, tzinfo = tzinfo, None
 
-        ts = convert_to_tsobject(ts_input, tz, unit, 0, 0)
+        ts = convert_to_tsobject(ts_input, tz, unit, 0, 0, nanosecond or 0)
 
         if ts.value == NPY_NAT:
             return NaT

pandas/tests/scalar/timestamp/test_timestamp.py

@@ -8,7 +8,7 @@
 
 from dateutil.tz import tzutc
 from pytz import timezone, utc
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, date
 
 import pandas.util.testing as tm
 import pandas.util._test_decorators as td
@@ -385,6 +385,19 @@ def test_constructor_fromordinal(self):
         ts = Timestamp.fromordinal(dt_tz.toordinal(), tz='US/Eastern')
         assert ts.to_pydatetime() == dt_tz
 
+    @pytest.mark.parametrize('result', [
+        Timestamp(datetime(2000, 1, 1), nanosecond=1),
+        Timestamp(date(2000, 1, 1), nanosecond=1),
+        Timestamp(year=2000, month=1, day=1, nanosecond=1),
+        Timestamp(year=2000, month=1, day=1, tz='UTC', nanosecond=1),
+        Timestamp(2000, 1, 1, 0, 0, 0, 0, None, 1),
+        Timestamp(2000, 1, 1, 0, 0, 0, 0, pytz.UTC, 1)])
+    def test_constructor_nanosecond(self, result):
+        # GH 18898
+        expected = Timestamp(datetime(2000, 1, 1), tz=result.tz)
+        expected = expected + Timedelta(nanoseconds=1)
+        assert result == expected
+
     def test_out_of_bounds_value(self):
         one_us = np.timedelta64(1).astype('timedelta64[us]')