Author: Brian Kearns <[email protected]>
Branch: py3k
Changeset: r69759:f94d90d4bded
Date: 2014-03-06 09:46 -0500
http://bitbucket.org/pypy/pypy/changeset/f94d90d4bded/
Log: cleanups for datetime, some from upstream
diff --git a/lib-python/3/datetime.py b/lib-python/3/datetime.py
--- a/lib-python/3/datetime.py
+++ b/lib-python/3/datetime.py
@@ -66,7 +66,7 @@
return _DAYS_IN_MONTH[month]
def _days_before_month(year, month):
- "year, month -> number of days in year preceeding first day of month."
+ "year, month -> number of days in year preceding first day of month."
assert 1 <= month <= 12, 'month must be in 1..12'
return _DAYS_BEFORE_MONTH[month] + (month > 2 and _is_leap(year))
@@ -316,7 +316,7 @@
raise TypeError("can't compare '%s' to '%s'" % (
type(x).__name__, type(y).__name__))
-class timedelta(object):
+class timedelta:
"""Represent the difference between two datetime objects.
Supported operators:
@@ -324,7 +324,7 @@
- add, subtract timedelta
- unary plus, minus, abs
- compare to timedelta
- - multiply, divide by int/long
+ - multiply, divide by int
In addition, datetime supports subtraction of two datetime objects
returning a timedelta, and addition or subtraction of a datetime
@@ -399,21 +399,18 @@
# secondsfrac isn't referenced again
if isinstance(microseconds, float):
- microseconds += usdouble
- microseconds = _round(microseconds)
+ microseconds = _round(microseconds + usdouble)
seconds, microseconds = divmod(microseconds, 1000000)
days, seconds = divmod(seconds, 24*3600)
d += days
- s += int(seconds)
- microseconds = int(microseconds)
+ s += seconds
else:
microseconds = int(microseconds)
seconds, microseconds = divmod(microseconds, 1000000)
days, seconds = divmod(seconds, 24*3600)
d += days
- s += int(seconds)
- microseconds += usdouble
- microseconds = _round(microseconds)
+ s += seconds
+ microseconds = _round(microseconds + usdouble)
assert isinstance(s, int)
assert isinstance(microseconds, int)
assert abs(s) <= 3 * 24 * 3600
@@ -640,7 +637,7 @@
microseconds=999999)
timedelta.resolution = timedelta(microseconds=1)
-class date(object):
+class date:
"""Concrete date type.
Constructors:
@@ -930,7 +927,7 @@
date.max = date(9999, 12, 31)
date.resolution = timedelta(days=1)
-class tzinfo(object):
+class tzinfo:
"""Abstract base class for time zone info classes.
Subclasses must override the name(), utcoffset() and dst() methods.
@@ -1000,7 +997,7 @@
_tzinfo_class = tzinfo
-class time(object):
+class time:
"""Time with time zone.
Constructors:
@@ -1039,7 +1036,8 @@
self = object.__new__(cls)
self.__setstate(hour, minute or None)
return self
- hour, minute, second, microsecond = _check_time_fields(hour, minute,
second, microsecond)
+ hour, minute, second, microsecond = _check_time_fields(
+ hour, minute, second, microsecond)
_check_tzinfo_arg(tzinfo)
self = object.__new__(cls)
self._hour = hour
@@ -1310,7 +1308,7 @@
"""datetime(year, month, day[, hour[, minute[, second[,
microsecond[,tzinfo]]]]])
The year, month and day arguments are required. tzinfo may be None, or an
- instance of a tzinfo subclass. The remaining arguments may be ints or
longs.
+ instance of a tzinfo subclass. The remaining arguments may be ints.
"""
__slots__ = date.__slots__ + time.__slots__
@@ -1322,7 +1320,8 @@
self.__setstate(year, month)
return self
year, month, day = _check_date_fields(year, month, day)
- hour, minute, second, microsecond = _check_time_fields(hour, minute,
second, microsecond)
+ hour, minute, second, microsecond = _check_time_fields(
+ hour, minute, second, microsecond)
_check_tzinfo_arg(tzinfo)
self = object.__new__(cls)
self._year = year
@@ -1367,7 +1366,6 @@
A timezone info object may be passed in as well.
"""
-
_check_tzinfo_arg(tz)
converter = _time.localtime if tz is None else _time.gmtime
@@ -1445,7 +1443,7 @@
def utctimetuple(self):
"Return UTC time tuple compatible with time.gmtime()."
offset = self.utcoffset()
- if offset: # neither None nor 0
+ if offset:
self -= offset
y, m, d = self.year, self.month, self.day
hh, mm, ss = self.hour, self.minute, self.second
@@ -1757,7 +1755,7 @@
def __setstate(self, string, tzinfo):
(yhi, ylo, self._month, self._day, self._hour,
- self._minute, self._second, us1, us2, us3) = string
+ self._minute, self._second, us1, us2, us3) = string
self._year = yhi * 256 + ylo
self._microsecond = (((us1 << 8) | us2) << 8) | us3
if tzinfo is None or isinstance(tzinfo, _tzinfo_class):
@@ -2092,6 +2090,7 @@
perverse time zone returns a negative dst()). So a breaking case must be
pretty bizarre, and a tzinfo subclass can override fromutc() if it is.
"""
+
try:
from _datetime import *
except ImportError:
diff --git a/lib-python/3/test/datetimetester.py
b/lib-python/3/test/datetimetester.py
--- a/lib-python/3/test/datetimetester.py
+++ b/lib-python/3/test/datetimetester.py
@@ -50,7 +50,7 @@
self.assertEqual(datetime.MAXYEAR, 9999)
def test_name_cleanup(self):
- if not '_Fast' in str(type(self)):
+ if '_Fast' not in str(self):
return
datetime = datetime_module
names = set(name for name in dir(datetime)
@@ -126,11 +126,11 @@
# carry no data), but they need to be picklable anyway else
# concrete subclasses can't be pickled.
orig = tzinfo.__new__(tzinfo)
- self.assertTrue(type(orig) is tzinfo)
+ self.assertIs(type(orig), tzinfo)
for pickler, unpickler, proto in pickle_choices:
green = pickler.dumps(orig, proto)
derived = unpickler.loads(green)
- self.assertTrue(type(derived) is tzinfo)
+ self.assertIs(type(derived), tzinfo)
def test_pickling_subclass(self):
# Make sure we can pickle/unpickle an instance of a subclass.
@@ -246,6 +246,8 @@
self.assertEqual(timezone(-5 * HOUR), timezone(-5 * HOUR, 'EST'))
with self.assertRaises(TypeError): timezone(ZERO) < timezone(ZERO)
self.assertIn(timezone(ZERO), {timezone(ZERO)})
+ self.assertTrue(timezone(ZERO) != None)
+ self.assertFalse(timezone(ZERO) == None)
def test_aware_datetime(self):
# test that timezone instances can be used by datetime
@@ -259,7 +261,7 @@
t.replace(tzinfo=tz).dst())
#############################################################################
-# Base clase for testing a particular aspect of timedelta, time, date and
+# Base class for testing a particular aspect of timedelta, time, date and
# datetime comparisons.
class HarmlessMixedComparison:
@@ -488,9 +490,9 @@
self.assertEqual(t1, t2)
self.assertTrue(t1 <= t2)
self.assertTrue(t1 >= t2)
- self.assertTrue(not t1 != t2)
- self.assertTrue(not t1 < t2)
- self.assertTrue(not t1 > t2)
+ self.assertFalse(t1 != t2)
+ self.assertFalse(t1 < t2)
+ self.assertFalse(t1 > t2)
for args in (3, 3, 3), (2, 4, 4), (2, 3, 5):
t2 = timedelta(*args) # this is larger than t1
@@ -500,12 +502,12 @@
self.assertTrue(t2 >= t1)
self.assertTrue(t1 != t2)
self.assertTrue(t2 != t1)
- self.assertTrue(not t1 == t2)
- self.assertTrue(not t2 == t1)
- self.assertTrue(not t1 > t2)
- self.assertTrue(not t2 < t1)
- self.assertTrue(not t1 >= t2)
- self.assertTrue(not t2 <= t1)
+ self.assertFalse(t1 == t2)
+ self.assertFalse(t2 == t1)
+ self.assertFalse(t1 > t2)
+ self.assertFalse(t2 < t1)
+ self.assertFalse(t1 >= t2)
+ self.assertFalse(t2 <= t1)
for badarg in OTHERSTUFF:
self.assertEqual(t1 == badarg, False)
@@ -618,6 +620,8 @@
eq(td(milliseconds=-0.5/1000), td(microseconds=-1))
eq(td(milliseconds=0.6/1000), td(microseconds=1))
eq(td(milliseconds=-0.6/1000), td(microseconds=-1))
+ eq(td(seconds=0.5/10**6), td(microseconds=1))
+ eq(td(seconds=-0.5/10**6), td(microseconds=-1))
# Rounding due to contributions from more than one field.
us_per_hour = 3600e6
@@ -640,7 +644,7 @@
self.assertTrue(timedelta(0, 1))
self.assertTrue(timedelta(0, 0, 1))
self.assertTrue(timedelta(microseconds=1))
- self.assertTrue(not timedelta(0))
+ self.assertFalse(timedelta(0))
def test_subclass_timedelta(self):
@@ -656,17 +660,17 @@
return round(sum)
t1 = T(days=1)
- self.assertTrue(type(t1) is T)
+ self.assertIs(type(t1), T)
self.assertEqual(t1.as_hours(), 24)
t2 = T(days=-1, seconds=-3600)
- self.assertTrue(type(t2) is T)
+ self.assertIs(type(t2), T)
self.assertEqual(t2.as_hours(), -25)
t3 = t1 + t2
- self.assertTrue(type(t3) is timedelta)
+ self.assertIs(type(t3), timedelta)
t4 = T.from_td(t3)
- self.assertTrue(type(t4) is T)
+ self.assertIs(type(t4), T)
self.assertEqual(t3.days, t4.days)
self.assertEqual(t3.seconds, t4.seconds)
self.assertEqual(t3.microseconds, t4.microseconds)
@@ -1018,8 +1022,9 @@
# It worked or it didn't. If it didn't, assume it's reason #2, and
# let the test pass if they're within half a second of each other.
- self.assertTrue(today == todayagain or
- abs(todayagain - today) < timedelta(seconds=0.5))
+ if today != todayagain:
+ self.assertAlmostEqual(todayagain, today,
+ delta=timedelta(seconds=0.5))
def test_weekday(self):
for i in range(7):
@@ -1213,9 +1218,9 @@
self.assertEqual(t1, t2)
self.assertTrue(t1 <= t2)
self.assertTrue(t1 >= t2)
- self.assertTrue(not t1 != t2)
- self.assertTrue(not t1 < t2)
- self.assertTrue(not t1 > t2)
+ self.assertFalse(t1 != t2)
+ self.assertFalse(t1 < t2)
+ self.assertFalse(t1 > t2)
for args in (3, 3, 3), (2, 4, 4), (2, 3, 5):
t2 = self.theclass(*args) # this is larger than t1
@@ -1225,12 +1230,12 @@
self.assertTrue(t2 >= t1)
self.assertTrue(t1 != t2)
self.assertTrue(t2 != t1)
- self.assertTrue(not t1 == t2)
- self.assertTrue(not t2 == t1)
- self.assertTrue(not t1 > t2)
- self.assertTrue(not t2 < t1)
- self.assertTrue(not t1 >= t2)
- self.assertTrue(not t2 <= t1)
+ self.assertFalse(t1 == t2)
+ self.assertFalse(t2 == t1)
+ self.assertFalse(t1 > t2)
+ self.assertFalse(t2 < t1)
+ self.assertFalse(t1 >= t2)
+ self.assertFalse(t2 <= t1)
for badarg in OTHERSTUFF:
self.assertEqual(t1 == badarg, False)
@@ -1696,9 +1701,9 @@
self.assertEqual(t1, t2)
self.assertTrue(t1 <= t2)
self.assertTrue(t1 >= t2)
- self.assertTrue(not t1 != t2)
- self.assertTrue(not t1 < t2)
- self.assertTrue(not t1 > t2)
+ self.assertFalse(t1 != t2)
+ self.assertFalse(t1 < t2)
+ self.assertFalse(t1 > t2)
for i in range(len(args)):
newargs = args[:]
@@ -1710,12 +1715,12 @@
self.assertTrue(t2 >= t1)
self.assertTrue(t1 != t2)
self.assertTrue(t2 != t1)
- self.assertTrue(not t1 == t2)
- self.assertTrue(not t2 == t1)
- self.assertTrue(not t1 > t2)
- self.assertTrue(not t2 < t1)
- self.assertTrue(not t1 >= t2)
- self.assertTrue(not t2 <= t1)
+ self.assertFalse(t1 == t2)
+ self.assertFalse(t2 == t1)
+ self.assertFalse(t1 > t2)
+ self.assertFalse(t2 < t1)
+ self.assertFalse(t1 >= t2)
+ self.assertFalse(t2 <= t1)
# A helper for timestamp constructor tests.
@@ -1793,7 +1798,7 @@
if abs(from_timestamp - from_now) <= tolerance:
break
# Else try again a few times.
- self.assertTrue(abs(from_timestamp - from_now) <= tolerance)
+ self.assertLessEqual(abs(from_timestamp - from_now), tolerance)
def test_strptime(self):
string = '2004-12-01 13:02:47.197'
@@ -2019,9 +2024,9 @@
self.assertEqual(t1, t2)
self.assertTrue(t1 <= t2)
self.assertTrue(t1 >= t2)
- self.assertTrue(not t1 != t2)
- self.assertTrue(not t1 < t2)
- self.assertTrue(not t1 > t2)
+ self.assertFalse(t1 != t2)
+ self.assertFalse(t1 < t2)
+ self.assertFalse(t1 > t2)
for i in range(len(args)):
newargs = args[:]
@@ -2033,12 +2038,12 @@
self.assertTrue(t2 >= t1)
self.assertTrue(t1 != t2)
self.assertTrue(t2 != t1)
- self.assertTrue(not t1 == t2)
- self.assertTrue(not t2 == t1)
- self.assertTrue(not t1 > t2)
- self.assertTrue(not t2 < t1)
- self.assertTrue(not t1 >= t2)
- self.assertTrue(not t2 <= t1)
+ self.assertFalse(t1 == t2)
+ self.assertFalse(t2 == t1)
+ self.assertFalse(t1 > t2)
+ self.assertFalse(t2 < t1)
+ self.assertFalse(t1 >= t2)
+ self.assertFalse(t2 <= t1)
for badarg in OTHERSTUFF:
self.assertEqual(t1 == badarg, False)
@@ -2216,8 +2221,8 @@
self.assertTrue(cls(0, 1))
self.assertTrue(cls(0, 0, 1))
self.assertTrue(cls(0, 0, 0, 1))
- self.assertTrue(not cls(0))
- self.assertTrue(not cls())
+ self.assertFalse(cls(0))
+ self.assertFalse(cls())
def test_replace(self):
cls = self.theclass
@@ -2317,7 +2322,7 @@
def utcoffset(self, dt): pass
b = BetterTry()
t = cls(1, 1, 1, tzinfo=b)
- self.assertTrue(t.tzinfo is b)
+ self.assertIs(t.tzinfo, b)
def test_utc_offset_out_of_bounds(self):
class Edgy(tzinfo):
@@ -2356,9 +2361,9 @@
for t in (cls(1, 1, 1),
cls(1, 1, 1, tzinfo=None),
cls(1, 1, 1, tzinfo=C1())):
- self.assertTrue(t.utcoffset() is None)
- self.assertTrue(t.dst() is None)
- self.assertTrue(t.tzname() is None)
+ self.assertIsNone(t.utcoffset())
+ self.assertIsNone(t.dst())
+ self.assertIsNone(t.tzname())
class C3(tzinfo):
def utcoffset(self, dt): return timedelta(minutes=-1439)
@@ -2453,7 +2458,7 @@
self.assertEqual(t.minute, 0)
self.assertEqual(t.second, 0)
self.assertEqual(t.microsecond, 0)
- self.assertTrue(t.tzinfo is None)
+ self.assertIsNone(t.tzinfo)
def test_zones(self):
est = FixedOffset(-300, "EST", 1)
@@ -2468,25 +2473,25 @@
self.assertEqual(t1.tzinfo, est)
self.assertEqual(t2.tzinfo, utc)
self.assertEqual(t3.tzinfo, met)
- self.assertTrue(t4.tzinfo is None)
+ self.assertIsNone(t4.tzinfo)
self.assertEqual(t5.tzinfo, utc)
self.assertEqual(t1.utcoffset(), timedelta(minutes=-300))
self.assertEqual(t2.utcoffset(), timedelta(minutes=0))
self.assertEqual(t3.utcoffset(), timedelta(minutes=60))
- self.assertTrue(t4.utcoffset() is None)
+ self.assertIsNone(t4.utcoffset())
self.assertRaises(TypeError, t1.utcoffset, "no args")
self.assertEqual(t1.tzname(), "EST")
self.assertEqual(t2.tzname(), "UTC")
self.assertEqual(t3.tzname(), "MET")
- self.assertTrue(t4.tzname() is None)
+ self.assertIsNone(t4.tzname())
self.assertRaises(TypeError, t1.tzname, "no args")
self.assertEqual(t1.dst(), timedelta(minutes=1))
self.assertEqual(t2.dst(), timedelta(minutes=-2))
self.assertEqual(t3.dst(), timedelta(minutes=3))
- self.assertTrue(t4.dst() is None)
+ self.assertIsNone(t4.dst())
self.assertRaises(TypeError, t1.dst, "no args")
self.assertEqual(hash(t1), hash(t2))
@@ -2538,7 +2543,7 @@
self.assertRaises(TypeError, t.strftime, "%Z")
# Issue #6697:
- if '_Fast' in str(type(self)):
+ if '_Fast' in str(self):
Badtzname.tz = '\ud800'
self.assertRaises(ValueError, t.strftime, "%Z")
@@ -2583,10 +2588,10 @@
self.assertTrue(t)
t = cls(5, tzinfo=FixedOffset(300, ""))
- self.assertTrue(not t)
+ self.assertFalse(t)
t = cls(23, 59, tzinfo=FixedOffset(23*60 + 59, ""))
- self.assertTrue(not t)
+ self.assertFalse(t)
# Mostly ensuring this doesn't overflow internally.
t = cls(0, tzinfo=FixedOffset(23*60 + 59, ""))
@@ -2624,13 +2629,13 @@
# Ensure we can get rid of a tzinfo.
self.assertEqual(base.tzname(), "+100")
base2 = base.replace(tzinfo=None)
- self.assertTrue(base2.tzinfo is None)
- self.assertTrue(base2.tzname() is None)
+ self.assertIsNone(base2.tzinfo)
+ self.assertIsNone(base2.tzname())
# Ensure we can add one.
base3 = base2.replace(tzinfo=z100)
self.assertEqual(base, base3)
- self.assertTrue(base.tzinfo is base3.tzinfo)
+ self.assertIs(base.tzinfo, base3.tzinfo)
# Out of bounds.
base = cls(1)
@@ -2865,7 +2870,7 @@
tz55 = FixedOffset(-330, "west 5:30")
timeaware = now.time().replace(tzinfo=tz55)
nowaware = self.theclass.combine(now.date(), timeaware)
- self.assertTrue(nowaware.tzinfo is tz55)
+ self.assertIs(nowaware.tzinfo, tz55)
self.assertEqual(nowaware.timetz(), timeaware)
# Can't mix aware and non-aware.
@@ -2884,15 +2889,15 @@
# Adding a delta should preserve tzinfo.
delta = timedelta(weeks=1, minutes=12, microseconds=5678)
nowawareplus = nowaware + delta
- self.assertTrue(nowaware.tzinfo is tz55)
+ self.assertIs(nowaware.tzinfo, tz55)
nowawareplus2 = delta + nowaware
- self.assertTrue(nowawareplus2.tzinfo is tz55)
+ self.assertIs(nowawareplus2.tzinfo, tz55)
self.assertEqual(nowawareplus, nowawareplus2)
# that - delta should be what we started with, and that - what we
# started with should be delta.
diff = nowawareplus - delta
- self.assertTrue(diff.tzinfo is tz55)
+ self.assertIs(diff.tzinfo, tz55)
self.assertEqual(nowaware, diff)
self.assertRaises(TypeError, lambda: delta - nowawareplus)
self.assertEqual(nowawareplus - nowaware, delta)
@@ -2901,7 +2906,7 @@
tzr = FixedOffset(random.randrange(-1439, 1440), "randomtimezone")
# Attach it to nowawareplus.
nowawareplus = nowawareplus.replace(tzinfo=tzr)
- self.assertTrue(nowawareplus.tzinfo is tzr)
+ self.assertIs(nowawareplus.tzinfo, tzr)
# Make sure the difference takes the timezone adjustments into account.
got = nowaware - nowawareplus
# Expected: (nowaware base - nowaware offset) -
@@ -2933,7 +2938,7 @@
off42 = FixedOffset(42, "42")
another = meth(off42)
again = meth(tz=off42)
- self.assertTrue(another.tzinfo is again.tzinfo)
+ self.assertIs(another.tzinfo, again.tzinfo)
self.assertEqual(another.utcoffset(), timedelta(minutes=42))
# Bad argument with and w/o naming the keyword.
self.assertRaises(TypeError, meth, 16)
@@ -2951,7 +2956,7 @@
timezone(timedelta(hours=15, minutes=58), "weirdtz"),]:
for dummy in range(3):
now = datetime.now(weirdtz)
- self.assertTrue(now.tzinfo is weirdtz)
+ self.assertIs(now.tzinfo, weirdtz)
utcnow = datetime.utcnow().replace(tzinfo=utc)
now2 = utcnow.astimezone(weirdtz)
if abs(now - now2) < timedelta(seconds=30):
@@ -2972,7 +2977,7 @@
off42 = FixedOffset(42, "42")
another = meth(ts, off42)
again = meth(ts, tz=off42)
- self.assertTrue(another.tzinfo is again.tzinfo)
+ self.assertIs(another.tzinfo, again.tzinfo)
self.assertEqual(another.utcoffset(), timedelta(minutes=42))
# Bad argument with and w/o naming the keyword.
self.assertRaises(TypeError, meth, ts, 16)
@@ -3183,13 +3188,13 @@
# Ensure we can get rid of a tzinfo.
self.assertEqual(base.tzname(), "+100")
base2 = base.replace(tzinfo=None)
- self.assertTrue(base2.tzinfo is None)
- self.assertTrue(base2.tzname() is None)
+ self.assertIsNone(base2.tzinfo)
+ self.assertIsNone(base2.tzname())
# Ensure we can add one.
base3 = base2.replace(tzinfo=z100)
self.assertEqual(base, base3)
- self.assertTrue(base.tzinfo is base3.tzinfo)
+ self.assertIs(base.tzinfo, base3.tzinfo)
# Out of bounds.
base = cls(2000, 2, 29)
@@ -3202,20 +3207,20 @@
fm5h = FixedOffset(-timedelta(hours=5), "m300")
dt = self.theclass.now(tz=f44m)
- self.assertTrue(dt.tzinfo is f44m)
+ self.assertIs(dt.tzinfo, f44m)
# Replacing with degenerate tzinfo raises an exception.
self.assertRaises(ValueError, dt.astimezone, fnone)
# Ditto with None tz.
self.assertRaises(TypeError, dt.astimezone, None)
# Replacing with same tzinfo makes no change.
x = dt.astimezone(dt.tzinfo)
- self.assertTrue(x.tzinfo is f44m)
+ self.assertIs(x.tzinfo, f44m)
self.assertEqual(x.date(), dt.date())
self.assertEqual(x.time(), dt.time())
# Replacing with different tzinfo does adjust.
got = dt.astimezone(fm5h)
- self.assertTrue(got.tzinfo is fm5h)
+ self.assertIs(got.tzinfo, fm5h)
self.assertEqual(got.utcoffset(), timedelta(hours=-5))
expected = dt - dt.utcoffset() # in effect, convert to UTC
expected += fm5h.utcoffset(dt) # and from there to local time
@@ -3223,7 +3228,7 @@
self.assertEqual(got.date(), expected.date())
self.assertEqual(got.time(), expected.time())
self.assertEqual(got.timetz(), expected.timetz())
- self.assertTrue(got.tzinfo is expected.tzinfo)
+ self.assertIs(got.tzinfo, expected.tzinfo)
self.assertEqual(got, expected)
def test_aware_subtract(self):
@@ -3665,8 +3670,8 @@
as_datetime = datetime.combine(as_date, time())
self.assertTrue(as_date != as_datetime)
self.assertTrue(as_datetime != as_date)
- self.assertTrue(not as_date == as_datetime)
- self.assertTrue(not as_datetime == as_date)
+ self.assertFalse(as_date == as_datetime)
+ self.assertFalse(as_datetime == as_date)
self.assertRaises(TypeError, lambda: as_date < as_datetime)
self.assertRaises(TypeError, lambda: as_datetime < as_date)
self.assertRaises(TypeError, lambda: as_date <= as_datetime)
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
