Changes behavior of create*() methods (time now defaults to 00:00:00)

Author: sdispater

docs/index.rst

@@ -142,19 +142,18 @@ besides behaving as expected, all accept a timezone parameter and each has their
 The next group of static helpers are the ``from_xxx()`` and ``create()`` helpers.
 Most of the static ``create`` functions allow you to provide
 as many or as few arguments as you want and will provide default values for all others.
-Generally default values are the current date, time or timezone.
+Generally default values are the current date, time set to ``00:00:00`` and ``UTC`` timezone.
 
 .. code-block:: python
 
     pendulum.from_date(year, month, day, tz)
     pendulum.from_time(hour, minute, second, microsecond, tz)
     pendulum.create(year, month, day, hour, minute, second, microsecond, tz)
 
-``from_date()`` will default the time to now. ``from_time()`` will default the date to today.
-``create()`` will default any null parameter to the current respective value.
-As before, the ``tz`` defaults to the ``UTC`` timezone and otherwise can be a ``tzinfo`` instance
-or simply a string timezone value. The only special case for default values occurs when an hour value
-is specified but no minutes or seconds, they will get defaulted to ``0``.
+``from_date()`` will default the time to ``00:00:00``. ``from_time()`` will default the date to today.
+``create()`` will default any null parameter to the current date for the date part and to ``00:00:00`` for time.
+As before, the ``tz`` defaults to the ``UTC`` timezone and otherwise can be a ``TimezoneInfo`` instance
+or simply a string timezone value.
 
 .. code-block:: python
 

pendulum/pendulum.py

@@ -268,9 +268,9 @@ def now(cls, tz=None):
         elif tz is UTC or tz == 'UTC':
             dt = datetime.datetime.utcnow().replace(tzinfo=UTC)
         else:
+            dt = datetime.datetime.utcnow().replace(tzinfo=UTC)
             tz = cls._safe_create_datetime_zone(tz)
-
-            return cls(*cls._create_datetime(tz))
+            dt = tz.convert(dt)
 
         return cls.instance(dt, tz)
 
@@ -322,43 +322,9 @@ def yesterday(cls, tz=None):
         """
         return cls.today(tz).subtract(days=1)
 
-    @classmethod
-    def _create_datetime(cls, tz, year=None, month=None, day=None,
-                         hour=None, minute=None, second=None, microsecond=None):
-        tzinfo = tz
-
-        if any([year is None, month is None, day is None,
-                hour is None, minute is None, second is None, microsecond is None]):
-            now = datetime.datetime.utcnow().replace(tzinfo=UTC)
-            now = tz.convert(now)
-
-            if year is None:
-                year = now.year
-
-            if month is None:
-                month = now.month
-
-            if day is None:
-                day = now.day
-
-            if hour is None:
-                hour = now.hour
-                minute = now.minute if minute is None else minute
-                second = now.second if second is None else second
-                microsecond = now.microsecond if microsecond is None else microsecond
-            else:
-                minute = 0 if minute is None else minute
-                second = 0 if second is None else second
-                microsecond = 0 if microsecond is None else microsecond
-
-            tzinfo = now.tzinfo
-
-        return (year, month, day,
-                hour, minute, second, microsecond, tzinfo)
-
     @classmethod
     def create(cls, year=None, month=None, day=None,
-               hour=None, minute=None, second=None, microsecond=None,
+               hour=0, minute=0, second=0, microsecond=0,
                tz=UTC):
         """
         Create a new Carbon instance from a specific date and time.
@@ -379,18 +345,30 @@ def create(cls, year=None, month=None, day=None,
         """
         tz = cls._safe_create_datetime_zone(tz)
 
-        dt = datetime.datetime(*cls._create_datetime(
-            tz, year, month, day, hour, minute, second, microsecond
-        )[:-1])
-        dt = tz.convert(dt, dst_rule=cls._TRANSITION_RULE)
+        if any([year is None, month is None, day is None]):
+            now = datetime.datetime.utcnow().replace(tzinfo=UTC)
+            now = tz.convert(now, dst_rule=cls._TRANSITION_RULE)
+
+            if year is None:
+                year = now.year
+
+            if month is None:
+                month = now.month
+
+            if day is None:
+                day = now.day
+
+        dt = datetime.datetime(
+            year, month, day, hour, minute, second, microsecond
+        )
 
-        return cls.instance(dt)
+        return cls.instance(dt, tz)
 
     @classmethod
     def create_from_date(cls, year=None, month=None, day=None, tz='UTC'):
         """
         Create a Pendulum instance from just a date.
-        The time portion is set to now.
+        The time portion is set to 00:00:00.
 
         :type year: int
         :type month: int
@@ -402,8 +380,8 @@ def create_from_date(cls, year=None, month=None, day=None, tz='UTC'):
         return cls.create(year, month, day, tz=tz)
 
     @classmethod
-    def create_from_time(cls, hour=None, minute=None, second=None,
-                         microsecond=None, tz='UTC'):
+    def create_from_time(cls, hour=0, minute=0, second=0,
+                         microsecond=0, tz='UTC'):
         """
         Create a Pendulum instance from just a time.
         The date portion is set to today.
@@ -2275,10 +2253,10 @@ def _getstate(self):
         )
 
     def __setstate__(self, year, month, day, hour, minute, second, microsecond, tz):
-        self._datetime = datetime.datetime(self._create_datetime(
-            tz, year, month, day,
+        self._datetime = tz.convert(datetime.datetime(
+            year, month, day,
             hour, minute, second, microsecond
-        )[:-1])
+        ))
         self._tz = tz
 
     def __reduce__(self):

tests/pendulum_tests/test_construct.py

@@ -127,3 +127,30 @@ def test_now(self):
         in_paris = Pendulum.now('Europe/Paris')
 
         self.assertNotEqual(now.hour, in_paris.hour)
+
+    def test_create(self):
+        with self.wrap_with_test_now():
+            now = Pendulum.now()
+            d = Pendulum.create()
+            self.assertPendulum(d, now.year, now.month, now.day, 0, 0, 0, 0)
+
+            d = Pendulum.create(year=1975)
+            self.assertPendulum(d, 1975, now.month, now.day, 0, 0, 0, 0)
+
+            d = Pendulum.create(month=11)
+            self.assertPendulum(d, now.year, 11, now.day, 0, 0, 0, 0)
+
+            d = Pendulum.create(day=27)
+            self.assertPendulum(d, now.year, now.month, 27, 0, 0, 0, 0)
+
+            d = Pendulum.create(hour=12)
+            self.assertPendulum(d, now.year, now.month, now.day, 12, 0, 0, 0)
+
+            d = Pendulum.create(minute=12)
+            self.assertPendulum(d, now.year, now.month, now.day, 0, 12, 0, 0)
+
+            d = Pendulum.create(second=12)
+            self.assertPendulum(d, now.year, now.month, now.day, 0, 0, 12, 0)
+
+            d = Pendulum.create(microsecond=123456)
+            self.assertPendulum(d, now.year, now.month, now.day, 0, 0, 0, 123456)

tests/pendulum_tests/test_create_from_date.py

@@ -9,12 +9,11 @@ class CreateFromDateTest(AbstractTestCase):
 
     def test_create_from_date_with_defaults(self):
         d = Pendulum.create_from_date()
-        self.assertEqual(d.timestamp, Pendulum.utcnow().timestamp)
+        self.assertEqual(d.timestamp, Pendulum.utcnow().with_time(0, 0, 0, 0).timestamp)
 
     def test_create_from_date(self):
         d = Pendulum.create_from_date(1975, 12, 25)
-        now = Pendulum.utcnow()
-        self.assertPendulum(d, 1975, 12, 25, now.hour, now.minute)
+        self.assertPendulum(d, 1975, 12, 25, 0, 0, 0)
 
     def test_create_from_date_with_year(self):
         d = Pendulum.create_from_date(1975)

tests/pendulum_tests/test_create_from_time.py

@@ -9,7 +9,7 @@ class CreateFromTimeTest(AbstractTestCase):
 
     def test_create_from_time_with_defaults(self):
         d = Pendulum.create_from_time()
-        self.assertEqual(d.timestamp, Pendulum.utcnow().timestamp)
+        self.assertEqual(d.timestamp, Pendulum.utcnow().with_time(0, 0, 0, 0).timestamp)
         self.assertEqual('UTC', d.timezone_name)
 
     def test_create_from_time(self):
@@ -22,9 +22,9 @@ def test_create_from_time_with_hour(self):
         with Pendulum.test(Pendulum(2016, 8, 11, 12, 34, 56, 123456)):
             d = Pendulum.create_from_time(23)
             self.assertEqual(23, d.hour)
-            self.assertEqual(34, d.minute)
-            self.assertEqual(56, d.second)
-            self.assertEqual(123456, d.microsecond)
+            self.assertEqual(0, d.minute)
+            self.assertEqual(0, d.second)
+            self.assertEqual(0, d.microsecond)
 
     def test_create_from_time_with_minute(self):
         d = Pendulum.create_from_time(minute=5)