path: root/devel/py-DateTime/files/patch-2to3

--- src/DateTime/DateTime.py.orig	2013-01-20 10:51:06 UTC
+++ src/DateTime/DateTime.py
@@ -11,7 +11,7 @@
 #
 ##############################################################################
 
-import copy_reg
+import copyreg
 import math
 import re
 from time import altzone
@@ -23,14 +23,14 @@ from time import timezone
 from time import tzname
 from datetime import datetime
 
-from pytz_support import PytzCache
+from .pytz_support import PytzCache
 from zope.interface import implements
 
-from interfaces import IDateTime
-from interfaces import DateTimeError
-from interfaces import SyntaxError
-from interfaces import DateError
-from interfaces import TimeError
+from .interfaces import IDateTime
+from .interfaces import DateTimeError
+from .interfaces import SyntaxError
+from .interfaces import DateError
+from .interfaces import TimeError
 
 default_datefmt = None
 
@@ -65,7 +65,7 @@ to_year = int(i * 365 + i / 4 - i / 100 + i / 400 - 69
 to_month = tm[yr % 4 == 0 and (yr % 100 != 0 or yr % 400 == 0)][mo]
 EPOCH = ((to_year + to_month + dy +
     (hr / 24.0 + mn / 1440.0 + sc / 86400.0)) * 86400)
-jd1901 = 2415385L
+jd1901 = 2415385
 
 _TZINFO = PytzCache()
 
@@ -201,14 +201,14 @@ def _calcDependentSecond(tz, t):
     # Calculates the timezone-dependent second (integer part only)
     # from the timezone-independent second.
     fset = _tzoffset(tz, t)
-    return fset + long(math.floor(t)) + long(EPOCH) - 86400L
+    return fset + int(math.floor(t)) + int(EPOCH) - 86400
 
 
 def _calcDependentSecond2(yr, mo, dy, hr, mn, sc):
     # Calculates the timezone-dependent second (integer part only)
     # from the date given.
     ss = int(hr) * 3600 + int(mn) * 60 + int(sc)
-    x = long(_julianday(yr, mo, dy) - jd1901) * 86400 + ss
+    x = int(_julianday(yr, mo, dy) - jd1901) * 86400 + ss
     return x
 
 
@@ -216,14 +216,14 @@ def _calcIndependentSecondEtc(tz, x, ms):
     # Derive the timezone-independent second from the timezone
     # dependent second.
     fsetAtEpoch = _tzoffset(tz, 0.0)
-    nearTime = x - fsetAtEpoch - long(EPOCH) + 86400L + ms
+    nearTime = x - fsetAtEpoch - int(EPOCH) + 86400 + ms
     # nearTime is now within an hour of being correct.
     # Recalculate t according to DST.
-    fset = long(_tzoffset(tz, nearTime))
+    fset = int(_tzoffset(tz, nearTime))
     d = (x - fset) / 86400.0 + (ms / 86400.0)
-    t = x - fset - long(EPOCH) + 86400L + ms
+    t = x - fset - int(EPOCH) + 86400 + ms
     micros = (x + 86400 - fset) * 1000000 + \
-             long(round(ms * 1000000.0)) - long(EPOCH * 1000000.0)
+             int(round(ms * 1000000.0)) - int(EPOCH * 1000000.0)
     s = d - math.floor(d)
     return (s, d, t, micros)
 
@@ -250,41 +250,41 @@ def _calcYMDHMS(x, ms):
 
 
 def _julianday(yr, mo, dy):
-    y, m, d = long(yr), long(mo), long(dy)
-    if m > 12L:
-        y = y + m / 12L
-        m = m % 12L
-    elif m < 1L:
+    y, m, d = int(yr), int(mo), int(dy)
+    if m > 12:
+        y = y + m / 12
+        m = m % 12
+    elif m < 1:
         m = -m
-        y = y - m / 12L - 1L
-        m = 12L - m % 12L
-    if y > 0L:
-        yr_correct = 0L
+        y = y - m / 12 - 1
+        m = 12 - m % 12
+    if y > 0:
+        yr_correct = 0
     else:
-        yr_correct = 3L
-    if m < 3L:
-        y, m = y - 1L, m + 12L
-    if y * 10000L + m * 100L + d > 15821014L:
-        b = 2L - y / 100L + y / 400L
+        yr_correct = 3
+    if m < 3:
+        y, m = y - 1, m + 12
+    if y * 10000 + m * 100 + d > 15821014:
+        b = 2 - y / 100 + y / 400
     else:
-        b = 0L
-    return ((1461L * y - yr_correct) / 4L +
-        306001L * (m + 1L) / 10000L + d + 1720994L + b)
+        b = 0
+    return ((1461 * y - yr_correct) / 4 +
+        306001 * (m + 1) / 10000 + d + 1720994 + b)
 
 
 def _calendarday(j):
-    j = long(j)
-    if (j < 2299160L):
-        b = j + 1525L
+    j = int(j)
+    if (j < 2299160):
+        b = j + 1525
     else:
-        a = (4L * j - 7468861L) / 146097L
-        b = j + 1526L + a - a / 4L
-    c = (20L * b - 2442L) / 7305L
-    d = 1461L * c / 4L
-    e = 10000L * (b - d) / 306001L
-    dy = int(b - d - 306001L * e / 10000L)
-    mo = (e < 14L) and int(e - 1L) or int(e - 13L)
-    yr = (mo > 2) and (c - 4716L) or (c - 4715L)
+        a = (4 * j - 7468861) / 146097
+        b = j + 1526 + a - a / 4
+    c = (20 * b - 2442) / 7305
+    d = 1461 * c / 4
+    e = 10000 * (b - d) / 306001
+    dy = int(b - d - 306001 * e / 10000)
+    mo = (e < 14) and int(e - 1) or int(e - 13)
+    yr = (mo > 2) and (c - 4716) or (c - 4715)
     return (int(yr), int(mo), int(dy))
 
 
@@ -317,7 +317,7 @@ def safegmtime(t):
     '''gmtime with a safety zone.'''
     try:
         t_int = int(t)
-        if isinstance(t_int, long):
+        if isinstance(t_int, int):
             raise OverflowError # Python 2.3 fix: int can return a long!
         return gmtime(t_int)
     except (ValueError, OverflowError):
@@ -329,7 +329,7 @@ def safelocaltime(t):
     '''localtime with a safety zone.'''
     try:
         t_int = int(t)
-        if isinstance(t_int, long):
+        if isinstance(t_int, int):
             raise OverflowError # Python 2.3 fix: int can return a long!
         return localtime(t_int)
     except (ValueError, OverflowError):
@@ -453,15 +453,15 @@ class DateTime(object):
     def __setstate__(self, value):
         if isinstance(value, tuple):
             self._parse_args(value[0], value[2])
-            self._micros = long(value[0] * 1000000)
+            self._micros = int(value[0] * 1000000)
             self._timezone_naive = value[1]
         else:
-            for k, v in value.items():
+            for k, v in list(value.items()):
                 if k in self.__slots__:
                     setattr(self, k, v)
             # BBB: support for very old DateTime pickles
             if '_micros' not in value:
-                self._micros = long(value['_t'] * 1000000)
+                self._micros = int(value['_t'] * 1000000)
             if '_timezone_naive' not in value:
                 self._timezone_naive = False
 
@@ -729,7 +729,7 @@ class DateTime(object):
                     tz = self._calcTimezoneName(x, ms)
                 s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)
 
-            elif (isinstance(arg, basestring) and
+            elif (isinstance(arg, str) and
                   arg.lower() in _TZINFO._zidx):
                 # Current time, to be displayed in specified timezone
                 t, tz = time(), _TZINFO._zmap[arg.lower()]
@@ -739,7 +739,7 @@ class DateTime(object):
                 x = _calcDependentSecond(tz, t)
                 yr, mo, dy, hr, mn, sc = _calcYMDHMS(x, ms)
 
-            elif isinstance(arg, basestring):
+            elif isinstance(arg, str):
                 # Date/time string
 
                 iso8601 = iso8601Match(arg.strip())
@@ -780,7 +780,7 @@ class DateTime(object):
                 sc = sc + ms
 
         elif ac==2:
-            if isinstance(args[1], basestring):
+            if isinstance(args[1], str):
                 # Seconds from epoch (gmt) and timezone
                 t, tz = args
                 ms = (t - math.floor(t))
@@ -800,7 +800,7 @@ class DateTime(object):
                 x_float = d * 86400.0
                 x_floor = math.floor(x_float)
                 ms = x_float - x_floor
-                x = long(x_floor)
+                x = int(x_floor)
                 yr, mo, dy, hr, mn, sc = _calcYMDHMS(x, ms)
                 s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)
         else:
@@ -838,7 +838,7 @@ class DateTime(object):
                 tz = self._calcTimezoneName(x, ms)
             s, d, t, microsecs = _calcIndependentSecondEtc(tz, x, ms)
 
-        self._dayoffset = int((_julianday(yr, mo, dy) + 2L) % 7)
+        self._dayoffset = int((_julianday(yr, mo, dy) + 2) % 7)
         # Round to nearest microsecond in platform-independent way.  You
         # cannot rely on C sprintf (Python '%') formatting to round
         # consistently; doing it ourselves ensures that all but truly
@@ -855,7 +855,7 @@ class DateTime(object):
         # self._micros is the time since the epoch
         # in long integer microseconds.
         if microsecs is None:
-            microsecs = long(math.floor(t * 1000000.0))
+            microsecs = int(math.floor(t * 1000000.0))
         self._micros = microsecs
 
     def localZone(self, ltm=None):
@@ -875,7 +875,7 @@ class DateTime(object):
         if not _multipleZones:
             return _localzone0
         fsetAtEpoch = _tzoffset(_localzone0, 0.0)
-        nearTime = x - fsetAtEpoch - long(EPOCH) + 86400L + ms
+        nearTime = x - fsetAtEpoch - int(EPOCH) + 86400 + ms
         # nearTime is within an hour of being correct.
         try:
             ltm = safelocaltime(nearTime)
@@ -887,7 +887,7 @@ class DateTime(object):
             yr, mo, dy, hr, mn, sc = _calcYMDHMS(x, 0)
             yr = ((yr - 1970) % 28) + 1970
             x = _calcDependentSecond2(yr, mo, dy, hr, mn, sc)
-            nearTime = x - fsetAtEpoch - long(EPOCH) + 86400L + ms
+            nearTime = x - fsetAtEpoch - int(EPOCH) + 86400 + ms
 
             # nearTime might still be negative if we are east of Greenwich.
             # But we can asume on 1969/12/31 were no timezone changes.
@@ -1242,7 +1242,7 @@ class DateTime(object):
         long integer microseconds.
         """
         if isinstance(t, float):
-            return self._micros > long(t * 1000000)
+            return self._micros > int(t * 1000000)
         try:
             return self._micros > t._micros
         except AttributeError:
@@ -1263,7 +1263,7 @@ class DateTime(object):
         long integer microseconds.
         """
         if isinstance(t, float):
-            return self._micros >= long(t * 1000000)
+            return self._micros >= int(t * 1000000)
         try:
             return self._micros >= t._micros
         except AttributeError:
@@ -1283,7 +1283,7 @@ class DateTime(object):
         long integer microseconds.
         """
         if isinstance(t, float):
-            return self._micros == long(t * 1000000)
+            return self._micros == int(t * 1000000)
         try:
             return self._micros == t._micros
         except AttributeError:
@@ -1328,7 +1328,7 @@ class DateTime(object):
         long integer microseconds.
         """
         if isinstance(t, float):
-            return self._micros < long(t * 1000000)
+            return self._micros < int(t * 1000000)
         try:
             return self._micros < t._micros
         except AttributeError:
@@ -1348,7 +1348,7 @@ class DateTime(object):
         long integer microseconds.
         """
         if isinstance(t, float):
-            return self._micros <= long(t * 1000000)
+            return self._micros <= int(t * 1000000)
         try:
             return self._micros <= t._micros
         except AttributeError:
@@ -1543,13 +1543,13 @@ class DateTime(object):
         # pass them to strftime and convert them back to unicode if necessary.
 
         format_is_unicode = False
-        if isinstance(format, unicode):
+        if isinstance(format, str):
             format = format.encode('utf-8')
             format_is_unicode = True
         ds = datetime(zself._year, zself._month, zself._day, zself._hour,
                zself._minute, int(zself._nearsec),
                microseconds).strftime(format)
-        return format_is_unicode and unicode(ds, 'utf-8') or ds
+        return format_is_unicode and str(ds, 'utf-8') or ds
 
     # General formats from previous DateTime
     def Date(self):
@@ -1737,7 +1737,7 @@ class DateTime(object):
         omicros = round(o * 86400000000)
         tmicros = self.micros() + omicros
         t = tmicros / 1000000.0
-        d = (tmicros + long(EPOCH*1000000)) / 86400000000.0
+        d = (tmicros + int(EPOCH*1000000)) / 86400000000.0
         s = d - math.floor(d)
         ms = t - math.floor(t)
         x = _calcDependentSecond(tz, t)
@@ -1789,7 +1789,7 @@ class DateTime(object):
 
     def __long__(self):
         """Convert to a long-int number of seconds since the epoch (gmt)."""
-        return long(self.micros() / 1000000)
+        return int(self.micros() / 1000000)
 
     def __float__(self):
         """Convert to floating-point number of seconds since the epoch (gmt).
@@ -1917,7 +1917,7 @@ class DateTime(object):
 # Provide the _dt_reconstructor function here, in case something
 # accidentally creates a reference to this function
 
-orig_reconstructor = copy_reg._reconstructor
+orig_reconstructor = copyreg._reconstructor
 
 
 def _dt_reconstructor(cls, base, state):
--- src/DateTime/pytz_support.py.orig	2011-12-09 05:59:48 UTC
+++ src/DateTime/pytz_support.py
@@ -18,7 +18,7 @@ import pytz
 import pytz.reference
 from pytz.tzinfo import StaticTzInfo, memorized_timedelta
 from datetime import datetime, timedelta
-from interfaces import DateTimeError
+from .interfaces import DateTimeError
 
 EPOCH = datetime.utcfromtimestamp(0).replace(tzinfo=pytz.utc)
 
@@ -198,7 +198,7 @@ def _static_timezone_factory(data):
     return cls()
 
 _numeric_timezones = dict((key, _static_timezone_factory(data))
-                           for key, data in _numeric_timezone_data.items())
+                           for key, data in list(_numeric_timezone_data.items()))
 
 
 class Timezone:
@@ -238,7 +238,7 @@ class PytzCache:
     _zlst = pytz.common_timezones + _old_zlst # used by DateTime.TimeZones
     _zmap = dict((name.lower(), name) for name in pytz.all_timezones)
     _zmap.update(_old_zmap) # These must take priority
-    _zidx = _zmap.keys()
+    _zidx = list(_zmap.keys())
 
     def __getitem__(self, key):
         name = self._zmap.get(key.lower(), key) # fallback to key
@@ -248,4 +248,4 @@ class PytzCache:
             try:
                 return Timezone(_numeric_timezones[name])
             except KeyError:
-                raise DateTimeError,'Unrecognized timezone: %s' % key
+                raise DateTimeError('Unrecognized timezone: %s' % key)
--- src/DateTime/tests/testDateTime.py.orig	2013-01-20 10:50:50 UTC
+++ src/DateTime/tests/testDateTime.py
@@ -12,7 +12,7 @@
 #
 ##############################################################################
 
-import cPickle
+import pickle
 import math
 import os
 import time
@@ -22,7 +22,7 @@ from DateTime.DateTime import _findLocalTimeZoneName
 from DateTime import DateTime
 from datetime import date, datetime, tzinfo, timedelta
 import pytz
-import legacy
+from . import legacy
 
 try:
     __file__
@@ -69,7 +69,7 @@ class DateTimeTests(unittest.TestCase):
     def testBug1203(self):
         # 01:59:60 occurred in old DateTime
         dt = DateTime(7200, 'GMT')
-        self.assert_(str(dt).find('60') < 0, dt)
+        self.assertTrue(str(dt).find('60') < 0, dt)
 
     def testDSTInEffect(self):
         # Checks GMT offset for a DST date in the US/Eastern time zone
@@ -116,7 +116,7 @@ class DateTimeTests(unittest.TestCase):
         dt = DateTime()
         dt1 = DateTime(float(dt), dt.timezone())
         self.assertEqual(str(dt), str(dt1), (dt, dt1))
-        dt1 = DateTime(float(dt), unicode(dt.timezone()))
+        dt1 = DateTime(float(dt), str(dt.timezone()))
         self.assertEqual(str(dt), str(dt1), (dt, dt1))
 
     def testConstructor6(self):
@@ -154,7 +154,7 @@ class DateTimeTests(unittest.TestCase):
         # Fails when an 1800 date is displayed with negative signs
         dt = DateTime('1830/5/6 12:31:46.213 pm')
         dt1 = dt.toZone('GMT+6')
-        self.assert_(str(dt1).find('-') < 0, (dt, dt1))
+        self.assertTrue(str(dt1).find('-') < 0, (dt, dt1))
 
     def testSubtraction(self):
         # Reconstruction of a DateTime from its parts, with subtraction
@@ -212,22 +212,22 @@ class DateTimeTests(unittest.TestCase):
 
     def test_pickle(self):
         dt = DateTime()
-        data = cPickle.dumps(dt, 1)
-        new = cPickle.loads(data)
+        data = pickle.dumps(dt, 1)
+        new = pickle.loads(data)
         for key in DateTime.__slots__:
             self.assertEqual(getattr(dt, key), getattr(new, key))
 
     def test_pickle_with_tz(self):
         dt = DateTime('2002/5/2 8:00am GMT+8')
-        data = cPickle.dumps(dt, 1)
-        new = cPickle.loads(data)
+        data = pickle.dumps(dt, 1)
+        new = pickle.loads(data)
         for key in DateTime.__slots__:
             self.assertEqual(getattr(dt, key), getattr(new, key))
 
     def test_pickle_with_micros(self):
         dt = DateTime('2002/5/2 8:00:14.123 GMT+8')
-        data = cPickle.dumps(dt, 1)
-        new = cPickle.loads(data)
+        data = pickle.dumps(dt, 1)
+        new = pickle.loads(data)
         for key in DateTime.__slots__:
             self.assertEqual(getattr(dt, key), getattr(new, key))
 
@@ -245,7 +245,7 @@ class DateTimeTests(unittest.TestCase):
             '\x1bM\xd2\x07U\x08_nearsecq\x1cG\x00\x00\x00\x00\x00\x00\x00'
             '\x00U\x07_pmhourq\x1dK\x08U\n_dayoffsetq\x1eK\x04U\x04timeq'
             '\x1fG?\xd5UUUV\x00\x00ub.')
-        new = cPickle.loads(data)
+        new = pickle.loads(data)
         for key in DateTime.__slots__:
             self.assertEqual(getattr(dt, key), getattr(new, key))
 
@@ -262,7 +262,7 @@ class DateTimeTests(unittest.TestCase):
             '\x04_dayq\x19K\x02U\x05_yearq\x1aM\xd2\x07U\x08_nearsecq'
             '\x1bG\x00\x00\x00\x00\x00\x00\x00\x00U\x07_pmhourq\x1cK\x08U'
             '\n_dayoffsetq\x1dK\x04U\x04timeq\x1eG?\xd5UUUV\x00\x00ub.')
-        new = cPickle.loads(data)
+        new = pickle.loads(data)
         for key in DateTime.__slots__:
             self.assertEqual(getattr(dt, key), getattr(new, key))
 
@@ -288,7 +288,7 @@ class DateTimeTests(unittest.TestCase):
         dsec = (dt.millis() - dt1.millis()) / 1000.0
         ddays = math.floor((dsec / 86400.0) + 0.5)
 
-        self.assertEqual(ddays, 3000000L, ddays)
+        self.assertEqual(ddays, 3000000, ddays)
 
     def test_tzoffset(self):
         # Test time-zone given as an offset
@@ -523,7 +523,7 @@ class DateTimeTests(unittest.TestCase):
 
     def test_calcTimezoneName(self):
         from DateTime.interfaces import TimeError
-        timezone_dependent_epoch = 2177452800L
+        timezone_dependent_epoch = 2177452800
         try:
             DateTime()._calcTimezoneName(timezone_dependent_epoch, 0)
         except TimeError:
@@ -556,8 +556,8 @@ class DateTimeTests(unittest.TestCase):
 
     def testStrftimeUnicode(self):
         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)
+        ok = dt.strftime('Le %d/%m/%Y a %Hh%M').replace('a', '\xe0')
+        self.assertEqual(dt.strftime('Le %d/%m/%Y \xe0 %Hh%M'), ok)
     
     def testTimezoneNaiveHandling(self):
         # checks that we assign timezone naivity correctly
@@ -615,11 +615,11 @@ class DateTimeTests(unittest.TestCase):
         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 _TZINFO._zidx, 'legacy timezone  %s cannot be looked up' % name)            
+        for name in legacy._zlst + list(legacy._zmap.keys()) + list(legacy._data.keys()):
+            self.assertTrue(name.lower() in _TZINFO._zidx, 'legacy timezone  %s cannot be looked up' % name)            
         
         failures = []
-        for name, zone in legacy.timezones.iteritems():
+        for name, zone in legacy.timezones.items():
             newzone = _TZINFO[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]:
@@ -637,7 +637,7 @@ class DateTimeTests(unittest.TestCase):
             
         real_failures = list(set(failures).difference(set(expected_failures)))
             
-        self.failIf(real_failures, '\n'.join(real_failures))
+        self.assertFalse(real_failures, '\n'.join(real_failures))
     
     def testBasicTZ(self):
         #psycopg2 supplies it's own tzinfo instances, with no `zone` attribute