[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