Makes the constructor behave like the standard one.

Author: sdispater

docs/index.rst

@@ -25,10 +25,7 @@ Pendulum is a Python package to ease datetimes manipulation.
 It is heavily inspired by `Carbon <http://carbon.nesbot.com>`_ for PHP.
 
 The ``Pendulum`` class is a drop-in replacement for the native ``datetime``
-class (it is inherited from it) with the exception that its mutable.
-
-Unlike the native class, most of the methods modify the current instance
-of ``Pendulum`` in place. If you want to modify a copy just use the ``copy()`` method.
+class (it is inherited from it).
 
 Special care has been taken to ensure timezones are handled correctly,
 and where appropriate are based on the underlying ``tzinfo`` implementation.
@@ -39,9 +36,10 @@ For example all comparisons are done in UTC or in the timezone of the datetime b
     dt_toronto = Pendulum.create_from_date(2012, 1, 1, 'America/Toronto')
     dt_vancouver = Pendulum.create_from_date(2012, 1, 1, 'America/Vancouver')
 
-    print(dt_vancouver.diff_in_hours(dt_toronto)) # 3
+    print(dt_vancouver.diff_in_hours(dt_toronto))
+    3
 
-The default timezone, except when using the ``now()`` method will always be ``UTC``.
+The default timezone, except when using the ``now()``, method will always be ``UTC``.
 
 .. note::
 
@@ -79,20 +77,16 @@ Instantiation
 =============
 
 There are several different methods available to create a new instance of Pendulum.
-First there is a constructor. It overrides the parent constructor to be more flexible.
-Basically, unlike ``datetime`` you can omit parameters and any omitted parameter will
-default to its ``now()`` value. However, if you provide the ``year``, ``month``, ``day``
-it will emulate the default ``datetime`` behavior.
+First there is a constructor. It accepts the same parameters as the standard class.
 
 .. code-block:: python
 
     from pendulum import Pendulum
 
-    dt = Pendulum() # equivalent to Pendulum.utcnow()
+    dt = Pendulum(2015, 2, 5, tzinfo='America/Vancouver')
     isinstance(dt, datetime)
     True
 
-    dt = Pendulum(2015, 2, 5, tzinfo='America/Vancouver')
     dt = Pendulum.now(-5)
 
 You'll notice above that the timezone (2nd) parameter was passed as a string and an integer
@@ -103,18 +97,20 @@ This is again shown in the next example which also introduces the ``now()`` func
 
 .. code-block:: python
 
-    now = Pendulum.now()
+    import pendulum
 
-    now_in_london_tz = Pendulum.now(pytz.timezone('Europe/London'))
+    now = pendulum.now()
+
+    now_in_london_tz = pendulum.now(pytz.timezone('Europe/London'))
 
     # or just pass the timezone as a string
-    now_in_london_tz = Pendulum.now('Europe/London')
+    now_in_london_tz = pendulum.now('Europe/London')
     print(now_in_london_tz.timezone_name)
     'Europe/London'
 
     # or to create a date with a timezone of +1 to GMT
     # during DST then just pass an integer
-    print(Pendulum.now(1).timezone_name))
+    print(pendulum.now(1).timezone_name))
     None
 
 .. note::
@@ -128,19 +124,19 @@ besides behaving as expected, all accept a timezone parameter and each has their
 
 .. code-block:: python
 
-    now = Pendulum.now()
+    now = pendulum.now()
     print(now)
     '2016-06-28T16:51:45.978473-05:00'
 
-    today = Pendulum.today()
+    today = pendulum.today()
     print(today)
     '2016-06-28T00:00:00-05:00'
 
-    tomorrow = Pendulum.tomorrow('Europe/London')
+    tomorrow = pendulum.tomorrow('Europe/London')
     print(tomorrow)
     '2016-06-29T00:00:00+01:00'
 
-    yesterday = Pendulum.yesterday()
+    yesterday = pendulum.yesterday()
     print(yesterday)
     '2016-06-27T00:00:00-05:00'
 
@@ -151,9 +147,9 @@ Generally default values are the current date, time or timezone.
 
 .. code-block:: python
 
-    Pendulum.create_from_date(year, month, day, tz)
-    Pendulum.create_from_time(hour, minute, second, microsecond, tz)
-    Pendulum.create(year, month, day, hour, minute, second, microsecond, tz)
+    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)
 
 ``create_from_date()`` will default the time to now. ``create_from_time()`` will default the date to today.
 ``create()`` will default any null parameter to the current respective value.
@@ -163,58 +159,62 @@ is specified but no minutes or seconds, they will get defaulted to ``0``.
 
 .. code-block:: python
 
-    xmas_this_year = Pendulum.create_from_date(None, 12, 25) # Year defaults to current year
-    y2k = Pendulum.create(2000, 1, 1, 0, 0, 0)
-    noon_london_tz = Pendulum.create_from_time(12, 0, 0, tz='Europe/London')
+    xmas_this_year = pendulum._from_date(None, 12, 25) # Year defaults to current year
+    y2k = pendulum.create(2000, 1, 1, 0, 0, 0)
+    noon_london_tz = pendulum.from_time(12, 0, 0, tz='Europe/London')
 
 .. code-block:: python
 
-    Pendulum.create_from_format(time, format, tz)
+    pendulum.from_format(time, format, tz)
 
 ``create_from_format()`` is mostly a wrapper for the base Python function ``datetime.strptime()``.
 The difference being the addition the ``tz`` argument that can be a ``tzinfo`` instance or a string timezone value
 (defaults to ``UTC``).
 
 .. code-block:: python
 
-    Pendulum.create_from_format('1975-05-21 22', '%Y-%m-%d %H').to_datetime_string()
+    pendulum.from_format('1975-05-21 22', '%Y-%m-%d %H').to_datetime_string()
     '1975-05-21 22:00:00'
-    Pendulum.create_from_format('1975-05-21 22', '%Y-%m-%d %H', 'Europe/London').isoformat()
+    pendulum.from_format('1975-05-21 22', '%Y-%m-%d %H', 'Europe/London').isoformat()
     '1975-05-21T22:00:00+01:00'
 
     # Using strptime is also possible (the timezone will be UTC)
-    Pendulum.strptime('1975-05-21 22', '%Y-%m-%d %H').isoformat()
+    pendulum.strptime('1975-05-21 22', '%Y-%m-%d %H').isoformat()
 
 The final ``create`` function is for working with unix timestamps.
 ``create_from_timestamp()`` will create a Pendulum instance equal to the given timestamp
 and will set the timezone as well or default it to ``UTC``.
 
 .. code-block:: python
 
-    Pendulum.create_from_timestamp(-1).to_datetime_string()
+    pendulum.from_timestamp(-1).to_datetime_string()
     '1969-12-31 23:59:59'
 
-    Pendulum.create_from_timestamp(-1, 'Europe/London').to_datetime_string()
+    pendulum.from_timestamp(-1, 'Europe/London').to_datetime_string()
     '1970-01-01 00:59:59'
 
+    # Using the standard fromtimestamp is also possible
+    pendulum.fromtimestamp(-1).to_datetime_string()
+    '1969-12-31 23:59:59'
+
 You can also create a ``copy()`` of an existing Pendulum instance.
 As expected the date, time and timezone values are all copied to the new instance.
 
 .. code-block:: python
 
-    dt = Pendulum.now()
-    print(dt.diff_in_years(dt.copy().add_year()))
+    dt = pendulum.now()
+    print(dt.diff(dt.copy().add_year()).in_years())
     1
 
-    # dt was unchanged and still holds the value of Pendulum.now()
+    # dt was unchanged and still holds the value of pendulum.now()
 
 Finally, if you find yourself inheriting a ``datetime`` instance,
-you can create a Pendulum instance via the ``instance()`` function.
+you can create a ``Pendulum`` instance via the ``instance()`` function.
 
 .. code-block:: python
 
     dt = datetime(2008, 1, 1)
-    p = Pendulum.instance(dt)
+    p = pendulum.instance(dt)
     print(p.to_datetime_string())
     '2008-01-01 00:00:00'
 

pendulum/pendulum.py

@@ -136,9 +136,9 @@ def _local_timezone(cls):
 
         return tzlocal.get_localzone()
 
-    def __new__(cls, year=1970, month=1, day=1,
-                 hour=0, minute=0, second=0, microsecond=0,
-                 tzinfo=None):
+    def __new__(cls, year, month, day,
+                hour=0, minute=0, second=0, microsecond=0,
+                tzinfo=None):
         """
         Constructor.
 
@@ -151,34 +151,11 @@ def __new__(cls, year=1970, month=1, day=1,
 
         return obj
 
-    def __init__(self, year=None, month=None, day=None,
-                 hour=None, minute=None, second=None, microsecond=None,
+    def __init__(self, year, month, day,
+                 hour=0, minute=0, second=0, microsecond=0,
                  tzinfo=pytz.UTC):
-        # If the class has a test now set and we are trying to create a now()
-        # instance then override as required
-        if (self.has_test_now()
-            and all([year is None, month is None, day is None, hour is None,
-                     minute is None, second is None, microsecond is None])):
-            test_instance = self._test_now
-
-            if tzinfo is not None and tzinfo != self._test_now.timezone:
-                test_instance = test_instance.in_timezone(tzinfo)
-            else:
-                tzinfo = test_instance.timezone
-
-            year, month, day = test_instance.year, test_instance.month, test_instance.day
-            hour, minute, second = test_instance.hour, test_instance.minute, test_instance.second
-            microsecond = test_instance.microsecond
-
         self._tz = self._safe_create_datetime_zone(tzinfo)
 
-        # Default datetime behavior
-        if year is not None and month is not None and day is not None:
-            hour = 0 if hour is None else hour
-            minute = 0 if minute is None else minute
-            second = 0 if second is None else second
-            microsecond = 0 if microsecond is None else microsecond
-
         self._datetime = self._create_datetime(
             self._tz, year, month, day,
             hour, minute, second, microsecond
@@ -240,7 +217,17 @@ def now(cls, tz=None):
 
         :rtype: Pendulum
         """
-        return cls(tzinfo=tz)
+        # If the class has a test now set and we are trying to create a now()
+        # instance then override as required
+        if (cls.has_test_now()):
+            test_instance = cls._test_now
+
+            if tz is not None and tz != cls._test_now.timezone:
+                test_instance = test_instance.in_timezone(tz)
+
+            return test_instance.copy()
+
+        return cls.create(tz=tz)
 
     @classmethod
     def utcnow(cls):
@@ -345,14 +332,12 @@ def create(cls, year=None, month=None, day=None,
         """
         tz = cls._safe_create_datetime_zone(tz)
 
-        self = cls()
-        self._tz = tz
-        self._datetime = cls._create_datetime(
+        dt = cls._create_datetime(
             tz, year, month, day,
             hour, minute, second, microsecond
         )
 
-        return self
+        return cls.instance(dt)
 
     @classmethod
     def create_from_date(cls, year=None, month=None, day=None, tz=pytz.UTC):

tests/pendulum_tests/test_add.py

@@ -9,28 +9,28 @@
 class AddTest(AbstractTestCase):
 
     def test_add_years_positive(self):
-        self.assertEqual(1976, Pendulum(1975).add_years(1).year)
+        self.assertEqual(1976, Pendulum.create(1975).add_years(1).year)
 
     def test_add_years_zero(self):
-        self.assertEqual(1975, Pendulum(1975).add_years(0).year)
+        self.assertEqual(1975, Pendulum.create(1975).add_years(0).year)
 
     def test_add_years_negative(self):
-        self.assertEqual(1974, Pendulum(1975).add_years(-1).year)
+        self.assertEqual(1974, Pendulum.create(1975).add_years(-1).year)
 
     def test_add_year(self):
-        self.assertEqual(1976, Pendulum(1975).add_year().year)
+        self.assertEqual(1976, Pendulum.create(1975).add_year().year)
 
     def test_add_months_positive(self):
-        self.assertEqual(1, Pendulum(1975, 12).add_months(1).month)
+        self.assertEqual(1, Pendulum.create(1975, 12).add_months(1).month)
 
     def test_add_months_zero(self):
-        self.assertEqual(12, Pendulum(1975, 12).add_months(0).month)
+        self.assertEqual(12, Pendulum.create(1975, 12).add_months(0).month)
 
     def test_add_months_negative(self):
-        self.assertEqual(11, Pendulum(1975, 12).add_months(-1).month)
+        self.assertEqual(11, Pendulum.create(1975, 12).add_months(-1).month)
 
     def test_add_month(self):
-        self.assertEqual(1, Pendulum(1975, 12).add_month().month)
+        self.assertEqual(1, Pendulum.create(1975, 12).add_month().month)
 
     def test_add_month_with_overflow(self):
         self.assertEqual(2, Pendulum(2012, 1, 31).add_month().month)

tests/pendulum_tests/test_construct.py

@@ -16,8 +16,8 @@ def tearDown(self):
             del os.environ['TZ']
 
     def test_creates_an_instance_default_to_utcnow(self):
-        p = Pendulum()
         now = Pendulum.utcnow()
+        p = Pendulum(now.year, now.month, now.day, now.hour, now.minute, now.second)
         self.assertIsInstanceOfPendulum(p)
         self.assertEqual(p.timezone_name, now.timezone_name)
 
@@ -41,7 +41,7 @@ def test_setting_timezone(self):
         dt = datetime.utcnow()
         offset = dtz.utcoffset(dt).total_seconds() / 3600
 
-        p = Pendulum(tzinfo=dtz)
+        p = Pendulum(dt.year, dt.month, dt.day, tzinfo=dtz)
         self.assertEqual(timezone, p.timezone_name)
         self.assertEqual(int(offset), p.offset_hours)
 
@@ -61,7 +61,7 @@ def test_setting_timezone_with_string(self):
         dt = datetime.utcnow()
         offset = dtz.utcoffset(dt).total_seconds() / 3600
 
-        p = Pendulum(tzinfo=timezone)
+        p = Pendulum(dt.year, dt.month, dt.day, tzinfo=timezone)
         self.assertEqual(timezone, p.timezone_name)
         self.assertEqual(int(offset), p.offset_hours)
 

tests/pendulum_tests/test_create_from_date.py

@@ -9,7 +9,7 @@ class CreateFromDateTest(AbstractTestCase):
 
     def test_create_from_date_with_defaults(self):
         d = Pendulum.create_from_date()
-        self.assertEqual(d.timestamp, Pendulum().timestamp)
+        self.assertEqual(d.timestamp, Pendulum.now().timestamp)
 
     def test_create_from_date(self):
         d = Pendulum.create_from_date(1975, 12, 25)

tests/pendulum_tests/test_create_from_time.py

@@ -10,7 +10,7 @@ class CreateFromTimeTest(AbstractTestCase):
 
     def test_create_from_time_with_defaults(self):
         d = Pendulum.create_from_time()
-        self.assertEqual(d.timestamp, Pendulum().timestamp)
+        self.assertEqual(d.timestamp, Pendulum.now().timestamp)
         self.assertEqual('UTC', d.timezone_name)
 
     def test_create_from_time(self):

tests/pendulum_tests/test_strings.py

@@ -7,18 +7,18 @@
 class StringsTest(AbstractTestCase):
 
     def test_to_string(self):
-        d = Pendulum(microsecond=0)
-        self.assertEqual(Pendulum(microsecond=0).to_iso8601_string(), str(d))
-        d = Pendulum(microsecond=123456)
-        self.assertEqual(Pendulum(microsecond=123456).to_iso8601_string(True), str(d))
+        d = Pendulum.create(microsecond=0)
+        self.assertEqual(Pendulum.create(microsecond=0).to_iso8601_string(), str(d))
+        d = Pendulum.create(microsecond=123456)
+        self.assertEqual(Pendulum.create(microsecond=123456).to_iso8601_string(True), str(d))
 
     def test_set_to_string_format(self):
         Pendulum.set_to_string_format('%a, %d %b %y %H:%M:%S %z')
         d = Pendulum(2016, 6, 27, 15, 39, 30)
         self.assertEqual('Mon, 27 Jun 16 15:39:30 +0000', str(d))
 
     def test_reset_to_string_format(self):
-        d = Pendulum(microsecond=0)
+        d = Pendulum.create(microsecond=0)
         Pendulum.set_to_string_format('123')
         Pendulum.reset_to_string_format()
         self.assertEqual(d.to_iso8601_string(), str(d))