kpriv/freebsd-ports
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
freebsd-ports/devel/py-DateTime/files/patch-2to3

527 lines
20 KiB
Text
Raw Normal View History

devel/py-DateTime: Fix build with setuptools 58.0.0+ With hat: python
2022-03-25 14:32:10 +01:00
--- 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
Reference in a new issue Copy permalink