[Checkins] SVN: DateTime/trunk/ Various cleanups, improve unpickling speed and distinguish between equal representations and references to equal points in time.

Hanno Schlichting hannosch at hannosch.eu
Fri May 6 10:21:23 EDT 2011


Log message for revision 121560:
  Various cleanups, improve unpickling speed and distinguish between equal representations and references to equal points in time.
  

Changed:
  U   DateTime/trunk/CHANGES.txt
  U   DateTime/trunk/setup.py
  U   DateTime/trunk/src/DateTime/DateTime.py
  U   DateTime/trunk/src/DateTime/DateTime.txt
  U   DateTime/trunk/src/DateTime/interfaces.py
  U   DateTime/trunk/src/DateTime/tests/testDateTime.py

-=-
Modified: DateTime/trunk/CHANGES.txt
===================================================================
--- DateTime/trunk/CHANGES.txt	2011-05-06 12:29:29 UTC (rev 121559)
+++ DateTime/trunk/CHANGES.txt	2011-05-06 14:21:22 UTC (rev 121560)
@@ -1,9 +1,19 @@
 Changelog
 =========
 
-2.12.7 (unreleased)
+2.13.0 (unreleased)
 -------------------
 
+- Optimized un-pickling, by avoiding the creation of an intermediate DateTime
+  value representing the current time.
+
+- Removed in-place migration of old DateTime pickles without a `_micros` value.
+
+- Removed deprecated support for using `DateTime.__cmp__`.
+
+- Take time zone settings into account when comparing two date times for
+  (non-) equality.
+
 - Fixed (possibly unused) _parse_iso8601 function.
   [thet]
 

Modified: DateTime/trunk/setup.py
===================================================================
--- DateTime/trunk/setup.py	2011-05-06 12:29:29 UTC (rev 121559)
+++ DateTime/trunk/setup.py	2011-05-06 14:21:22 UTC (rev 121560)
@@ -16,7 +16,7 @@
 from setuptools import setup, find_packages
 
 setup(name='DateTime',
-      version = '2.12.7dev',
+      version = '2.13.0dev',
       url='http://pypi.python.org/pypi/DateTime',
       license='ZPL 2.1',
       description="""\

Modified: DateTime/trunk/src/DateTime/DateTime.py
===================================================================
--- DateTime/trunk/src/DateTime/DateTime.py	2011-05-06 12:29:29 UTC (rev 121559)
+++ DateTime/trunk/src/DateTime/DateTime.py	2011-05-06 14:21:22 UTC (rev 121560)
@@ -12,12 +12,11 @@
 ##############################################################################
 """Encapsulation of date/time values"""
 
-__version__='$Revision: 1.99 $'[11:-2]
 
-
 import re, math
 from time import time, gmtime, localtime
 from time import daylight, timezone, altzone
+from time import tzname
 from datetime import datetime
 from interfaces import IDateTime
 from interfaces import DateTimeError, SyntaxError, DateError, TimeError
@@ -40,11 +39,6 @@
         return default_datefmt
 
 
-try:
-    from time import tzname
-except:
-    tzname=('UNKNOWN','UNKNOWN')
-
 # To control rounding errors, we round system time to the nearest
 # microsecond.  Then delicate calculations can rely on that the
 # maximum precision that needs to be preserved is known.
@@ -343,21 +337,20 @@
     DateTimeError = DateTimeError
     SyntaxError = SyntaxError
 
-    def __init__(self,*args, **kw):
+    def __init__(self, *args, **kw):
         """Return a new date-time object"""
-
+        if args and args[0] is None:
+            # unpickle
+            return
         try:
             return self._parse_args(*args, **kw)
         except (DateError, TimeError, DateTimeError):
             raise
-        except:
+        except Exception:
             raise SyntaxError('Unable to parse %s, %s' % (args, kw))
 
-    def __setstate__(self, state):
-        self.__dict__.clear()  # why doesn't Python's unpickler do this?
-        self.__dict__.update(state)
-        if '_micros' not in state:
-            self._micros = self._upgrade_old()
+    def __getinitargs__(self):
+        return (None, )
 
     def _parse_args(self, *args, **kw):
         """Return a new date-time object.
@@ -713,7 +706,6 @@
                                 raise DateTimeError,'Too many arguments'
             if not self._validTime(hr,mn,sc):
                 raise TimeError, 'Invalid time: %s' % `args`
-            leap = (yr % 4 == 0) and (yr % 100 != 0 or yr % 400 == 0)
 
             x = _calcDependentSecond2(yr,mo,dy,hr,mn,sc)
             ms = sc - math.floor(sc)
@@ -1035,9 +1027,6 @@
         return year,month,day,hr,mn,sc,tz
 
     # Internal methods
-    def __getinitargs__(self):
-        return (None,)
-
     def _validDate(self,y,m,d):
         if m<1 or m>12 or y<0 or d<1 or d>31:
             return 0
@@ -1163,7 +1152,7 @@
         return self.__class__(self._year,self._month,self._day,
                               23,59,59,self._tz)
 
-    def greaterThan(self,t):
+    def greaterThan(self, t):
         """Compare this DateTime object to another DateTime object
         OR a floating point number such as that which is returned
         by the python time module.
@@ -1174,13 +1163,9 @@
         Revised to give more correct results through comparison of
         long integer microseconds.
         """
-        # Optimized for sorting speed
-        try:
-            return (self._micros > t._micros)
-        except AttributeError:
-            try: self._micros
-            except AttributeError: self._upgrade_old()
-        return (self._t > t)
+        if isinstance(t, float):
+            return self._t > t
+        return self._micros > t._micros
 
     __gt__ = greaterThan
 
@@ -1196,17 +1181,13 @@
         Revised to give more correct results through comparison of
         long integer microseconds.
         """
-        # Optimized for sorting speed
-        try:
-            return (self._micros >= t._micros)
-        except AttributeError:
-            try: self._micros
-            except AttributeError: self._upgrade_old()
-        return (self._t >= t)
+        if isinstance(t, float):
+            return self._t >= t
+        return self._micros >= t._micros
 
     __ge__ = greaterThanEqualTo
 
-    def equalTo(self,t):
+    def equalTo(self, t):
         """Compare this DateTime object to another DateTime object
         OR a floating point number such as that which is returned
         by the python time module.
@@ -1217,17 +1198,11 @@
         Revised to give more correct results through comparison of
         long integer microseconds.
         """
-        # Optimized for sorting speed
-        try:
-            return (self._micros == t._micros)
-        except AttributeError:
-            try: self._micros
-            except AttributeError: self._upgrade_old()
-        return (self._t == t)
+        if isinstance(t, float):
+            return self._t == t
+        return self._micros == t._micros
 
-    __eq__ = equalTo
-
-    def notEqualTo(self,t):
+    def notEqualTo(self, t):
         """Compare this DateTime object to another DateTime object
         OR a floating point number such as that which is returned
         by the python time module.
@@ -1238,16 +1213,22 @@
         Revised to give more correct results through comparison of
         long integer microseconds.
         """
-        # Optimized for sorting speed
-        try:
-            return (self._micros != t._micros)
-        except AttributeError:
-            try: self._micros
-            except AttributeError: self._upgrade_old()
-        return (self._t != t)
+        return not self.equalTo(t)
 
-    __ne__ = notEqualTo
+    def __eq__(self, t):
+        """Compare this DateTime object to another DateTime object.
+        Return True if their internal state is the same. Two objects
+        representing the same time in different timezones are regared as
+        unequal. Use the equalTo method if you are only interested in them
+        refering to the same moment in time.
+        """
+        if not isinstance(t, DateTime):
+            return False
+        return (self._micros, self._tz) == (t._micros, t._tz)
 
+    def __ne__(self, t):
+        return not self.__eq__(t)
+
     def lessThan(self,t):
         """Compare this DateTime object to another DateTime object
         OR a floating point number such as that which is returned
@@ -1259,13 +1240,9 @@
         Revised to give more correct results through comparison of
         long integer microseconds.
         """
-        # Optimized for sorting speed
-        try:
-            return (self._micros < t._micros)
-        except AttributeError:
-            try: self._micros
-            except AttributeError: self._upgrade_old()
-        return (self._t < t)
+        if isinstance(t, float):
+            return self._t < t
+        return self._micros < t._micros
 
     __lt__ = lessThan
 
@@ -1280,13 +1257,9 @@
         Revised to give more correct results through comparison of
         long integer microseconds.
         """
-        # Optimized for sorting speed
-        try:
-            return (self._micros <= t._micros)
-        except AttributeError:
-            try: self._micros
-            except AttributeError: self._upgrade_old()
-        return (self._t <= t)
+        if isinstance(t, float):
+            return self._t <= t
+        return self._micros <= t._micros
 
     __le__ = lessThanEqualTo
 
@@ -1406,18 +1379,11 @@
 
     def millis(self):
         """Return the millisecond since the epoch in GMT."""
-        try:
-            micros = self._micros
-        except AttributeError:
-            micros = self._upgrade_old()
-        return micros / 1000
+        return self._micros / 1000
 
     def micros(self):
         """Return the microsecond since the epoch in GMT."""
-        try:
-            return self._micros
-        except AttributeError:
-            return self._upgrade_old()
+        return self._micros
 
     def timezoneNaive(self):
         """The python datetime module introduces the idea of distinguishing
@@ -1431,12 +1397,6 @@
         except AttributeError:
             return None
 
-    def _upgrade_old(self):
-        """Upgrades a previously pickled DateTime object."""
-        micros = long(math.floor(self._t * 1000000.0))
-        #self._micros = micros # don't upgrade instances in place
-        return micros
-
     def strftime(self, format):
         """Format the date/time using the *current timezone representation*."""
         x = _calcDependentSecond2(self._year, self._month, self._day,
@@ -1687,26 +1647,6 @@
             return '%4.4d/%2.2d/%2.2d %2.2d:%2.2d:%06.6f %s' % (
                     y, m, d, h, mn, s, t)
 
-    def __cmp__(self,obj):
-        """Compare a DateTime with another DateTime object, or a
-        float such as those returned by time.time().
-
-        NOTE: __cmp__ support is provided for backward compatibility
-        only, and mixing DateTimes with ExtensionClasses could cause
-        __cmp__ to break.
-
-        You should use the methods lessThan, greaterThan, lessThanEqualTo,
-        greaterThanEqualTo, equalTo and notEqualTo to avoid potential
-        problems later!
-        """
-        # Optimized for sorting speed.
-        try:
-            return cmp(self._micros, obj._micros)
-        except AttributeError:
-            try: self._micros
-            except AttributeError: self._upgrade_old()
-        return cmp(self._t,obj)
-
     def __hash__(self):
         """Compute a hash value for a DateTime."""
         return int(((self._year%100*12+self._month)*31+

Modified: DateTime/trunk/src/DateTime/DateTime.txt
===================================================================
--- DateTime/trunk/src/DateTime/DateTime.txt	2011-05-06 12:29:29 UTC (rev 121559)
+++ DateTime/trunk/src/DateTime/DateTime.txt	2011-05-06 14:21:22 UTC (rev 121560)
@@ -183,7 +183,7 @@
 
   Only their representations are different:
 
-    >>> now_east == now_west
+    >>> now_east.equalTo(now_west)
     True
 
 * If the function is invoked with three or more numeric arguments,
@@ -237,7 +237,7 @@
     >>> dt.toZone('UTC')
     DateTime('1997/03/09 18:45:00 UTC')
 
-    >>> dt.toZone('UTC') == dt
+    >>> dt.toZone('UTC').equalTo(dt)
     True
 
 * ``isFuture()`` returns true if this object represents a date/time
@@ -620,40 +620,12 @@
   >>> hash(dt.toZone('UTC'))
   3618678
 
-A DateTime can be compared with another DateTime or float via
-``cmp()``.  NOTE: __cmp__ support is provided for backward
-compatibility only, and mixing DateTimes with ExtensionClasses could
-cause __cmp__ to break.  You should use the methods lessThan,
-greaterThan, lessThanEqualTo, greaterThanEqualTo, equalTo and
-notEqualTo to avoid potential problems later!
-
-  >>> cmp(dt, dt)
-  0
-  >>> cmp(dt, dt.toZone('UTC'))
-  0
-  >>> cmp(dt, dt.timeTime())
-  0
-
-  >>> cmp(dt, DateTime('2000/01/01'))
-  -1
-  >>> cmp(dt, DateTime('1900/01/01'))
-  1
-
 DateTime objects can be compared to other DateTime objects OR floating
 point numbers such as the ones which are returned by the python time
-module.  On comparison for equality, True is returned if the object
-represents a date/time equal to the specified DateTime or time module
+module by using the equalTo method. Using this API, True is returned if the
+object represents a date/time equal to the specified DateTime or time module
 style time:
 
-  >>> dt == dt
-  True
-  >>> dt == dt.toZone('UTC')
-  True
-  >>> dt == dt.timeTime()
-  True
-  >>> dt == DateTime()
-  False
-
   >>> dt.equalTo(dt)
   True
   >>> dt.equalTo(dt.toZone('UTC'))
@@ -665,24 +637,35 @@
 
 Same goes for inequalities:
 
-  >>> dt != dt
+  >>> dt.notEqualTo(dt)
   False
-  >>> dt != dt.toZone('UTC')
+  >>> dt.notEqualTo(dt.toZone('UTC'))
   False
-  >>> dt != dt.timeTime()
+  >>> dt.notEqualTo(dt.timeTime())
   False
-  >>> dt != DateTime()
+  >>> dt.notEqualTo(DateTime())
   True
 
-  >>> dt.notEqualTo(dt)
+Normal equality operations only work with datetime objects and take the
+timezone setting into account:
+
+  >>> dt == dt
+  True
+  >>> dt == dt.toZone('UTC')
   False
-  >>> dt.notEqualTo(dt.toZone('UTC'))
+  >>> dt == DateTime()
   False
-  >>> dt.notEqualTo(dt.timeTime())
+
+  >>> dt != dt
   False
-  >>> dt.notEqualTo(DateTime())
+  >>> dt != dt.toZone('UTC')
   True
+  >>> dt != DateTime()
+  True
 
+But the other comparison operations compare the referenced moment in time and
+not the representation itself:
+
   >>> dt > dt
   False
   >>> DateTime() > dt

Modified: DateTime/trunk/src/DateTime/interfaces.py
===================================================================
--- DateTime/trunk/src/DateTime/interfaces.py	2011-05-06 12:29:29 UTC (rev 121559)
+++ DateTime/trunk/src/DateTime/interfaces.py	2011-05-06 14:21:22 UTC (rev 121560)
@@ -362,16 +362,6 @@
     def __str__():
         """Convert a DateTime to a string."""
 
-    def __cmp__(obj):
-        """Compare a DateTime with another DateTime object, or a float
-        such as those returned by time.time().
-
-        NOTE: __cmp__ support is provided for backward compatibility
-        only, and mixing DateTimes with ExtensionClasses could cause
-        __cmp__ to break.  You should use the methods lessThan,
-        greaterThan, lessThanEqualTo, greaterThanEqualTo, equalTo and
-        notEqualTo to avoid potential problems later!!"""
-
     def __hash__():
         """Compute a hash value for a DateTime"""
 

Modified: DateTime/trunk/src/DateTime/tests/testDateTime.py
===================================================================
--- DateTime/trunk/src/DateTime/tests/testDateTime.py	2011-05-06 12:29:29 UTC (rev 121559)
+++ DateTime/trunk/src/DateTime/tests/testDateTime.py	2011-05-06 14:21:22 UTC (rev 121560)
@@ -175,13 +175,13 @@
         # Time zone manipulation: add to a date
         dt = DateTime('1997/3/8 1:45am GMT-4')
         dt1 = DateTime('1997/3/9 1:45pm GMT+8')
-        self.assertEqual(dt + 1.0, dt1, (dt, dt1))
+        self.assertTrue((dt + 1.0).equalTo(dt1))
 
     def testTZ1sub(self):
         # Time zone manipulation: subtract from a date
         dt = DateTime('1997/3/8 1:45am GMT-4')
         dt1 = DateTime('1997/3/9 1:45pm GMT+8')
-        self.assertEqual(dt1 - 1.0, dt, (dt, dt1))
+        self.assertTrue((dt1 - 1.0).equalTo(dt))
 
     def testTZ1diff(self):
         # Time zone manipulation: diff two dates
@@ -200,74 +200,18 @@
         self.failUnless(dt.notEqualTo(dt1))
         self.failUnless(not dt.equalTo(dt1))
 
-    def testCompareOperations(self, dt=None, dt1=None):
-        # Compare two dates using several operations
-        if dt is None:
-            dt = DateTime('1997/1/1')
-        if dt1 is None:
-            dt1 = DateTime('1997/2/2')
-        self.failUnless(dt1 > dt)
-        self.failUnless(dt1 >= dt)
-        self.failUnless(dt < dt1)
-        self.failUnless(dt <= dt1)
-        self.failUnless(dt != dt1)
-        self.failUnless(not (dt == dt1))
+    def test_pickle(self):
+        import cPickle
+        dt = DateTime()
+        data = cPickle.dumps(dt, 1)
+        new = cPickle.loads(data)
+        self.assertEqual(dt.__dict__, new.__dict__)
 
-    def test_compare_old_instances(self):
-        # Compare dates that don't have the _micros attribute yet
-        # (e.g., from old pickles).
-        dt = DateTime('1997/1/1')
-        dt1 = DateTime('1997/2/2')
-        dt._millis = dt._micros / 1000
-        del dt._micros
-        dt1._millis = dt1._micros / 1000
-        del dt1._micros
-        self.testCompareOperations(dt, dt1)
+        dt = DateTime('2002/5/2 8:00am GMT+0')
+        data = cPickle.dumps(dt, 1)
+        new = cPickle.loads(data)
+        self.assertEqual(dt.__dict__, new.__dict__)
 
-    def test_compare_old_new_instances(self):
-        # Compare a date without _micros attribute (e.g., from an old
-        # pickle) with one that does.
-        dt = DateTime('1997/1/1')
-        dt1 = DateTime('1997/2/2')
-        dt._millis = dt._micros / 1000
-        del dt._micros
-        self.testCompareOperations(dt, dt1)
-
-    def test_compare_new_old_instances(self):
-        # Compare a date with _micros attribute with one that does not
-        # (e.g., from an old pickle).
-        dt = DateTime('1997/1/1')
-        dt1 = DateTime('1997/2/2')
-        dt1._millis = dt._micros / 1000
-        del dt1._micros
-        self.testCompareOperations(dt, dt1)
-
-    def test_strftime_old_instance(self):
-        # https://bugs.launchpad.net/zope2/+bug/290254
-        # Ensure that dates without _micros attribute (e.g., from old
-        # pickles) still render correctly in strftime.
-        ISO = '2001-10-10T00:00:00+02:00'
-        dt = DateTime(ISO)
-        dt._millis = dt._micros / 1000
-        del dt._micros
-        self.assertEqual(dt.strftime('%Y'), '2001')
-
-        # Now, create one via pickling / unpickling.
-        from cPickle import dumps, loads
-        self.assertEqual(loads(dumps(dt)).strftime('%Y'), '2001')
-
-    def test___setstate___without_micros(self):
-        ISO = '2001-10-10T00:00:00+02:00'
-        dt = DateTime(ISO)
-        micros = dt._micros
-        dt._millis = dt._micros / 1000
-        del dt._micros
-        state = dt.__dict__
-
-        dt1 = DateTime()
-        dt1.__setstate__(state)
-        self.assertEqual(dt1._micros, micros)
-
     def testTZ2(self):
         # Time zone manipulation test 2
         dt = DateTime()
@@ -340,91 +284,91 @@
         # be interpreted in the local timezone, to preserve backwards
         # compatibility with previously expected behaviour.
         isoDt = DateTime('2002-05-02T08:00:00')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
         isoDt = DateTime('2002-05-02T08:00:00Z')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
         isoDt = DateTime('2002-05-02T08:00:00+00:00')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
         isoDt = DateTime('2002-05-02T08:00:00-04:00')
-        self.assertEqual(ref1, isoDt)
+        self.assertTrue(ref1.equalTo(isoDt))
         isoDt = DateTime('2002-05-02 08:00:00-04:00')
-        self.assertEqual(ref1, isoDt)
+        self.assertTrue(ref1.equalTo(isoDt))
 
         # Bug 1386: the colon in the timezone offset is optional
         isoDt = DateTime('2002-05-02T08:00:00-0400')
-        self.assertEqual(ref1, isoDt)
+        self.assertTrue(ref1.equalTo(isoDt))
 
         # Bug 2191: date reduced formats
         isoDt = DateTime('2006-01-01')
-        self.assertEqual(ref4, isoDt)
+        self.assertTrue(ref4.equalTo(isoDt))
         isoDt = DateTime('200601-01')
-        self.assertEqual(ref4, isoDt)
+        self.assertTrue(ref4.equalTo(isoDt))
         isoDt = DateTime('20060101')
-        self.assertEqual(ref4, isoDt)
+        self.assertTrue(ref4.equalTo(isoDt))
         isoDt = DateTime('2006-01')
-        self.assertEqual(ref4, isoDt)
+        self.assertTrue(ref4.equalTo(isoDt))
         isoDt = DateTime('200601')
-        self.assertEqual(ref4, isoDt)
+        self.assertTrue(ref4.equalTo(isoDt))
         isoDt = DateTime('2006')
-        self.assertEqual(ref4, isoDt)
+        self.assertTrue(ref4.equalTo(isoDt))
 
         # Bug 2191: date/time separators are also optional
         isoDt = DateTime('20020502T08:00:00')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
         isoDt = DateTime('2002-05-02T080000')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
         isoDt = DateTime('20020502T080000')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
 
         # Bug 2191: timezones with only one digit for hour
         isoDt = DateTime('20020502T080000+0')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
         isoDt = DateTime('20020502 080000-4')
-        self.assertEqual(ref1, isoDt)
+        self.assertTrue(ref1.equalTo(isoDt))
         isoDt = DateTime('20020502T080000-400')
-        self.assertEqual(ref1, isoDt)
+        self.assertTrue(ref1.equalTo(isoDt))
         isoDt = DateTime('20020502T080000-4:00')
-        self.assertEqual(ref1, isoDt)
+        self.assertTrue(ref1.equalTo(isoDt))
 
         # Bug 2191: optional seconds/minutes
         isoDt = DateTime('2002-05-02T0800')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
         isoDt = DateTime('2002-05-02T08')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
 
         # Bug 2191: week format
         isoDt = DateTime('2002-W18-4T0800')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
         isoDt = DateTime('2002-W184T0800')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
         isoDt = DateTime('2002W18-4T0800')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
         isoDt = DateTime('2002W184T08')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
         isoDt = DateTime('2004-W25-1T14:30:15-03:00')
-        self.assertEqual(ref3, isoDt)
+        self.assertTrue(ref3.equalTo(isoDt))
         isoDt = DateTime('2004-W25T14:30:15-03:00')
-        self.assertEqual(ref3, isoDt)
+        self.assertTrue(ref3.equalTo(isoDt))
 
         # Bug 2191: day of year format
         isoDt = DateTime('2002-122T0800')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
         isoDt = DateTime('2002122T0800')
-        self.assertEqual(ref0, isoDt)
+        self.assertTrue(ref0.equalTo(isoDt))
 
         # Bug 2191: hours/minutes fractions
         isoDt = DateTime('2006-11-06T10.5')
-        self.assertEqual(ref2, isoDt)
+        self.assertTrue(ref2.equalTo(isoDt))
         isoDt = DateTime('2006-11-06T10,5')
-        self.assertEqual(ref2, isoDt)
+        self.assertTrue(ref2.equalTo(isoDt))
         isoDt = DateTime('20040614T1430.25-3')
-        self.assertEqual(ref3, isoDt)
+        self.assertTrue(ref3.equalTo(isoDt))
         isoDt = DateTime('2004-06-14T1430,25-3')
-        self.assertEqual(ref3, isoDt)
+        self.assertTrue(ref3.equalTo(isoDt))
         isoDt = DateTime('2004-06-14T14:30.25-3')
-        self.assertEqual(ref3, isoDt)
+        self.assertTrue(ref3.equalTo(isoDt))
         isoDt = DateTime('20040614T14:30,25-3')
-        self.assertEqual(ref3, isoDt)
+        self.assertTrue(ref3.equalTo(isoDt))
 
         # ISO8601 standard format
         iso8601_string = '2002-05-02T08:00:00-04:00'
@@ -433,7 +377,7 @@
 
         # ISO format with no timezone
         isoDt = DateTime('2006-01-01 00:00:00')
-        self.assertEqual(ref4, isoDt)
+        self.assertTrue(ref4.equalTo(isoDt))
 
     def testJulianWeek(self):
         # Check JulianDayWeek function
@@ -556,7 +500,7 @@
         dt = DateTime('2002-05-02T08:00:00+00:00')
         ok = dt.strftime('Le %d/%m/%Y a %Hh%M').replace('a', u'\xe0')
         self.assertEqual(dt.strftime(u'Le %d/%m/%Y \xe0 %Hh%M'), ok)
-
+    
     def testTimezoneNaiveHandling(self):
         # checks that we assign timezone naivity correctly
         dt = DateTime('2007-10-04T08:00:00+00:00')
@@ -577,7 +521,7 @@
         s = '2007-10-04T08:00:00+00:00'
         dt = DateTime(s)
         self.assertEqual(s, dt.ISO8601())
-
+    
     def testConversions(self):
         sdt0 = datetime.now() # this is a timezone naive datetime
         dt0 = DateTime(sdt0)
@@ -585,18 +529,18 @@
         sdt1 = datetime(2007, 10, 4, 18, 14, 42, 580, pytz.utc)
         dt1 = DateTime(sdt1)
         assert dt1.timezoneNaive() is False, (sdt1, dt1)
-
+        
         # convert back
         sdt2 = dt0.asdatetime()
         self.assertEqual(sdt0, sdt2)
         sdt3 = dt1.utcdatetime() # this returns a timezone naive datetime
         self.assertEqual(sdt1.hour, sdt3.hour)
-
+        
         dt4 = DateTime('2007-10-04T10:00:00+05:00')
         sdt4 = datetime(2007, 10, 4, 5, 0)
         self.assertEqual(dt4.utcdatetime(), sdt4)
         self.assertEqual(dt4.asdatetime(), sdt4.replace(tzinfo=pytz.utc))
-
+        
         dt5 = DateTime('2007-10-23 10:00:00 US/Eastern')
         tz = pytz.timezone('US/Eastern')
         sdt5 = datetime(2007, 10, 23, 10, 0, tzinfo=tz)
@@ -606,23 +550,23 @@
         self.assertEqual(dt5, dt6)
         self.assertEqual(dt5.asdatetime().tzinfo, tz)
         self.assertEqual(dt6.asdatetime().tzinfo, tz)
-
+    
     def testLegacyTimezones(self):
         cache = _cache()
         # The year is important here as timezones change over time
         t1 = time.mktime(datetime(2002, 1, 1).timetuple())
         t2 = time.mktime(datetime(2002, 7, 1).timetuple())
-
+        
         for name in legacy._zlst + legacy._zmap.keys() + legacy._data.keys():
-            self.failUnless(name.lower() in cache._zidx, 'legacy timezone  %s cannot be looked up' % name)
-
+            self.failUnless(name.lower() in cache._zidx, 'legacy timezone  %s cannot be looked up' % name)            
+        
         failures = []
         for name, zone in legacy.timezones.iteritems():
             newzone = cache[name]
             # The name of the new zone might change (eg GMT+6 rather than GMT+0600)
             if zone.info(t1)[:2] != newzone.info(t1)[:2] or zone.info(t2)[:2] != newzone.info(t2)[:2]:
                 failures.append(name)
-
+                
         expected_failures = [ # zone.info(t1)     newzone.info(t1)     zone.info(t2)     newzone.info(t2)
             'Jamaica',        # (-18000, 0, 'EST') (-18000, 0, 'EST') (-14400, 1, 'EDT') (-18000, 0, 'EST')
             'Turkey',         # (10800, 0, 'EET') (7200, 0, 'EET') (14400, 1, 'EET DST') (10800, 1, 'EEST')
@@ -632,11 +576,11 @@
             'Brazil/West',    # (-10800, 1, 'WDT') (-14400, 0, 'AMT') (-14400, 0, 'WST') (-14400, 0, 'AMT')
             'Brazil/Acre',    # (-14400, 1, 'ADT') (-18000, 0, 'ACT') (-18000, 0, 'AST') (-18000, 0, 'ACT')
             ]
-
+            
         real_failures = list(set(failures).difference(set(expected_failures)))
-
+            
         self.failIf(real_failures, '\n'.join(real_failures))
-
+    
     def testBasicTZ(self):
         #psycopg2 supplies it's own tzinfo instances, with no `zone` attribute
         tz = FixedOffset(60, 'GMT+1')



More information about the checkins mailing list