Lines Matching defs:tzinfo
29 from datetime import tzinfo
89 'tzinfo', 'UTC', 'sys'])
121 # tzinfo tests
123 class FixedOffset(tzinfo):
150 class _TZInfo(tzinfo):
166 useless = tzinfo()
173 class NotEnough(tzinfo):
177 self.assertTrue(issubclass(NotEnough, tzinfo))
179 self.assertIsInstance(ne, tzinfo)
188 self.assertIsInstance(fo, tzinfo)
195 # There's no point to pickling tzinfo objects on their own (they
198 orig = tzinfo.__new__(tzinfo)
199 self.assertIs(type(orig), tzinfo)
203 self.assertIs(type(derived), tzinfo)
215 self.assertIsInstance(orig, tzinfo)
222 self.assertIsInstance(derived, tzinfo)
231 class UKSummerTime(tzinfo):
246 u = datetime(2014, 4, 26, 12, 1, tzinfo=tz)
296 self.assertIsInstance(timezone.utc, tzinfo)
297 self.assertIsInstance(self.EST, tzinfo)
345 utctime = self.DT.replace(tzinfo=tz)
349 self.DT.replace(tzinfo=timezone.utc))
377 t.replace(tzinfo=tz).tzname())
379 t.replace(tzinfo=tz).utcoffset())
381 t.replace(tzinfo=tz).dst())
435 # Constructing tzinfo objects directly should not be done by users
437 self.assertNotEqual(timezone.utc, tzinfo())
438 self.assertNotEqual(timezone(timedelta(hours=1)), tzinfo())
1814 # Good bytes, but bad tzinfo:
1815 with self.assertRaisesRegex(TypeError, '^bad tzinfo state arg$'):
2063 t = self.theclass(1, 2, 3, 4, 5, 1, 999500, tzinfo=timezone.utc)
2082 t = self.theclass(2, 3, 2, tzinfo=tz)
2110 dt = dt_base.replace(tzinfo=tzi)
2179 # verify ok if tzinfo.tzname().replace() returns a non-string
2466 t = self.theclass(1970, 1, 1, tzinfo=timezone.utc)
2468 t = self.theclass(1970, 1, 1, 1, 2, 3, 4, tzinfo=timezone.utc)
2472 tzinfo=timezone(timedelta(hours=-5), 'EST'))
2519 min_dt = self.theclass.min.replace(tzinfo=timezone.utc)
2528 max_dt = self.theclass.max.replace(tzinfo=timezone.utc,
2581 min_dt = self.theclass.min.replace(tzinfo=timezone.utc)
2584 max_dt = self.theclass.max.replace(microsecond=0, tzinfo=timezone.utc)
2588 ("minimum", min_ts, min_dt.replace(tzinfo=None)),
2589 ("maximum", max_ts, max_dt.replace(tzinfo=None)),
2710 self.assertEqual(strptime("UTC", "%Z").tzinfo, None)
2779 t = t.replace(tzinfo=tz)
2811 self.assertRaises(TypeError, combine, d, t, 1) # wrong tzinfo type
2817 # tzinfo= argument
2819 self.assertIs(dt.tzinfo, timezone.utc)
2820 dt = combine(d, t, tzinfo=timezone.utc)
2821 self.assertIs(dt.tzinfo, timezone.utc)
2856 dt_utc = dt.replace(tzinfo=timezone(timedelta(hours=-4), 'EDT'))
2860 dt_f = dt.replace(tzinfo=f) + timedelta(hours=4, minutes=44)
2864 class Bogus(tzinfo):
2869 self.assertEqual(dt.replace(tzinfo=bog).astimezone(f), dt_f)
2871 class AlsoBogus(tzinfo):
2877 class Broken(tzinfo):
2881 dt_broken = dt.replace(tzinfo=broken)
3007 dts = [self.theclass(*date_tuple, *time_tuple, tzinfo=tzi)
3038 dt = base_dt.replace(tzinfo=tzi)
3093 dt = self.theclass(*(dt_tuple[0:(4 + ip)]), tzinfo=tzi)
3186 self.theclass(2024, 12, 30, 3, 0, tzinfo=UTC)),
3188 self.theclass(2025, 1, 2, 3, 4, 5, tzinfo=UTC)),
3190 self.theclass(2025, 1, 2, 3, 4, 5, tzinfo=UTC)),
3192 self.theclass(2025, 1, 2, 3, 4, 5, 600000, tzinfo=UTC)),
3194 self.theclass(2000, 1, 1, 0, 0, tzinfo=timezone(timedelta(hours=21)))),
3197 tzinfo=timezone(timedelta(hours=3)))),
3200 tzinfo=timezone(timedelta(hours=-3)))),
3202 self.theclass(2025, 1, 2, 3, 4, 5, tzinfo=UTC)),
3205 tzinfo=timezone(timedelta(hours=3)))),
3208 tzinfo=timezone(timedelta(hours=-3)))),
3210 self.theclass(2020, 1, 1, 3, 5, 7, 123457, tzinfo=EST)),
3212 self.theclass(2020, 1, 1, 3, 5, 7, 123457, tzinfo=EST)),
3214 self.theclass(2020, 6, 1, 4, 5, 6, 111111, tzinfo=EDT)),
3216 self.theclass(2020, 6, 1, 4, 5, 6, 111111, tzinfo=EDT)),
3218 self.theclass(2021, 10, 31, 1, 30, tzinfo=BST)),
3220 self.theclass(2021, 10, 31, 1, 30, tzinfo=BST)),
3222 self.theclass(2025, 1, 2, 3, 4, 5, 600000, tzinfo=UTC)),
3225 tzinfo=timezone(timedelta(seconds=10)))),
3281 self.assertIs(dt.tzinfo, timezone.utc)
3288 tzinfo=timezone(timedelta(hours=10, minutes=45)))
3506 t = t_base.replace(tzinfo=tzi)
3695 # Good bytes, but bad tzinfo:
3696 with self.assertRaisesRegex(TypeError, '^bad tzinfo state arg$'):
3699 # A mixin for classes with a tzinfo= argument. Subclasses must define
3700 # theclass as a class attribute, and theclass(1, 1, 1, tzinfo=whatever)
3707 class introspective(tzinfo):
3713 obj = cls(1, 2, 3, tzinfo=introspective())
3724 self.assertRaises(TypeError, cls, 1, 1, 1, tzinfo=12)
3729 self.assertRaises(TypeError, cls, 1, 1, 1, tzinfo=NiceTry)
3731 class BetterTry(tzinfo):
3735 t = cls(1, 1, 1, tzinfo=b)
3736 self.assertIs(t.tzinfo, b)
3739 class Edgy(tzinfo):
3751 t = cls(1, 2, 3, tzinfo=Edgy(offset))
3753 t = cls(6, 6, 6, 1, 2, 3, tzinfo=Edgy(offset))
3768 class C1(tzinfo):
3773 cls(1, 1, 1, tzinfo=None),
3774 cls(1, 1, 1, tzinfo=C1())):
3779 class C3(tzinfo):
3783 t = cls(1, 1, 1, tzinfo=C3())
3789 class C4(tzinfo):
3793 t = cls(1, 1, 1, tzinfo=C4())
3799 class C6(tzinfo):
3802 t = cls(1, 1, 1, tzinfo=C6())
3807 class C7(tzinfo):
3810 t = cls(1, 1, 1, tzinfo=C7())
3818 # the same tzinfo member.
3819 class OperandDependentOffset(tzinfo):
3828 base = cls(8, 9, 10, tzinfo=OperandDependentOffset())
3841 # though (and time.utcoffset() passes None to tzinfo.utcoffset()),
3844 d0 = base.replace(minute=3, tzinfo=OperandDependentOffset())
3845 d1 = base.replace(minute=9, tzinfo=OperandDependentOffset())
3846 d2 = base.replace(minute=11, tzinfo=OperandDependentOffset())
3862 # Testing time objects with a non-None tzinfo.
3872 self.assertIsNone(t.tzinfo)
3878 t1 = time( 7, 47, tzinfo=est)
3879 t2 = time(12, 47, tzinfo=utc)
3880 t3 = time(13, 47, tzinfo=met)
3882 t5 = time(microsecond=40, tzinfo=utc)
3884 self.assertEqual(t1.tzinfo, est)
3885 self.assertEqual(t2.tzinfo, utc)
3886 self.assertEqual(t3.tzinfo, met)
3887 self.assertIsNone(t4.tzinfo)
3888 self.assertEqual(t5.tzinfo, utc)
3932 self.assertEqual(repr(t1), d + "(7, 47, tzinfo=est)")
3933 self.assertEqual(repr(t2), d + "(12, 47, tzinfo=utc)")
3934 self.assertEqual(repr(t3), d + "(13, 47, tzinfo=met)")
3936 self.assertEqual(repr(t5), d + "(0, 0, 0, 40, tzinfo=utc)")
3944 t1 = time(23, 59, tzinfo=yuck)
3949 class Badtzname(tzinfo):
3952 t = time(2, 3, 4, tzinfo=Badtzname())
3963 t1 = self.theclass(0, 1, 2, 3, tzinfo=FixedOffset(1439, ""))
3964 t2 = self.theclass(0, 0, 2, 3, tzinfo=FixedOffset(1438, ""))
3967 t1 = self.theclass(23, 58, 6, 100, tzinfo=FixedOffset(-1000, ""))
3968 t2 = self.theclass(23, 48, 6, 100, tzinfo=FixedOffset(-1010, ""))
3972 # Try one without a tzinfo.
3981 # Try one with a tzinfo.
3983 orig = self.theclass(5, 6, 7, tzinfo=tinfo)
3988 self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)
4018 expected = self.theclass(5, 6, 7, 123456, tzinfo=tinfo)
4023 self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)
4031 t = cls(0, tzinfo=FixedOffset(-300, ""))
4034 t = cls(5, tzinfo=FixedOffset(-300, ""))
4037 t = cls(5, tzinfo=FixedOffset(300, ""))
4040 t = cls(23, 59, tzinfo=FixedOffset(23*60 + 59, ""))
4056 ("tzinfo", zm200)):
4064 # Ensure we can get rid of a tzinfo.
4066 base2 = base.replace(tzinfo=None)
4067 self.assertIsNone(base2.tzinfo)
4071 base3 = base2.replace(tzinfo=z100)
4073 self.assertIs(base.tzinfo, base3.tzinfo)
4086 t2 = t2.replace(tzinfo=None)
4088 t2 = t2.replace(tzinfo=FixedOffset(None, ""))
4090 t2 = t2.replace(tzinfo=FixedOffset(0, ""))
4093 # In time w/ identical tzinfo objects, utcoffset is ignored.
4094 class Varies(tzinfo):
4102 t1 = t2.replace(tzinfo=v)
4103 t2 = t2.replace(tzinfo=v)
4109 t2 = t2.replace(tzinfo=Varies())
4131 t = self.theclass(*ttup, tzinfo=tzi)
4156 t = base_time.replace(tzinfo=tzi)
4184 t = self.theclass(*(t_tuple[0:(1 + ip)]), tzinfo=tzi)
4240 ('00:00:00Z', self.theclass(0, 0, tzinfo=timezone.utc)),
4241 ('12:00:00+0000', self.theclass(12, 0, tzinfo=timezone.utc)),
4242 ('12:00:00+00:00', self.theclass(12, 0, tzinfo=timezone.utc)),
4244 self.theclass(0, 0, tzinfo=timezone(timedelta(hours=5)))),
4246 self.theclass(0, 0, tzinfo=timezone(timedelta(hours=5, minutes=30)))),
4248 self.theclass(12, 0, tzinfo=timezone(timedelta(hours=-5)))),
4250 self.theclass(12, 0, tzinfo=timezone(timedelta(hours=-5)))),
4252 self.theclass(0, 0, tzinfo=timezone(-timedelta(hours=23, minutes=59, seconds=59, microseconds=999999)))),
4304 tsc = TimeSubclass(12, 14, 45, 203745, tzinfo=timezone.utc)
4337 # Testing datetime objects with a non-None tzinfo.
4351 self.assertEqual(dt.tzinfo, None)
4355 # and TestDateTime covered non-tzinfo cases.
4358 t1 = self.theclass(1, 1, 1, tzinfo=FixedOffset(1439, ""))
4361 tzinfo=FixedOffset(-1439, ""))
4372 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""))
4373 t2 = self.theclass(2, 1, 1, 3, 13, tzinfo=FixedOffset(3*60+13+2, ""))
4377 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(0, ""))
4381 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(2, ""))
4385 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""),
4390 t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""),
4402 # It's also naive if it has tzinfo but tzinfo.utcoffset() is None.
4403 class Naive(tzinfo):
4405 t2 = self.theclass(5, 6, 7, tzinfo=Naive())
4415 class Bogus(tzinfo):
4418 t1 = self.theclass(2, 2, 2, tzinfo=Bogus())
4419 t2 = self.theclass(2, 2, 2, tzinfo=FixedOffset(0, ""))
4423 # Try one without a tzinfo.
4432 # Try one with a tzinfo.
4434 orig = self.theclass(*args, **{'tzinfo': tinfo})
4435 derived = self.theclass(1, 1, 1, tzinfo=FixedOffset(0, "", 0))
4440 self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)
4473 expected = self.theclass(*args, **{'tzinfo': tinfo})
4478 self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)
4486 t = self.theclass(1, 1, 1, tzinfo=FixedOffset(1439, ""))
4489 tzinfo=FixedOffset(-1439, ""))
4493 t = self.theclass(5, 5, 5, tzinfo=FixedOffset(-1440, ""))
4500 t1 = datetime(2002, 3, 19, 7, 47, tzinfo=est)
4501 t2 = datetime(2002, 3, 19, 12, 47, tzinfo=utc)
4502 t3 = datetime(2002, 3, 19, 13, 47, tzinfo=met)
4503 self.assertEqual(t1.tzinfo, est)
4504 self.assertEqual(t2.tzinfo, utc)
4505 self.assertEqual(t3.tzinfo, met)
4522 self.assertEqual(repr(t1), d + "7, 47, tzinfo=est)")
4523 self.assertEqual(repr(t2), d + "12, 47, tzinfo=utc)")
4524 self.assertEqual(repr(t3), d + "13, 47, tzinfo=met)")
4529 tz = time(18, 45, 3, 1234, tzinfo=met)
4532 tzinfo=met))
4536 dt = self.theclass(2002, 3, 4, 18, 45, 3, 1234, tzinfo=met)
4539 self.assertEqual(dt.timetz(), time(18, 45, 3, 1234, tzinfo=met))
4544 timeaware = now.time().replace(tzinfo=tz55)
4546 self.assertIs(nowaware.tzinfo, tz55)
4562 # Adding a delta should preserve tzinfo.
4565 self.assertIs(nowaware.tzinfo, tz55)
4567 self.assertIs(nowawareplus2.tzinfo, tz55)
4573 self.assertIs(diff.tzinfo, tz55)
4581 nowawareplus = nowawareplus.replace(tzinfo=tzr)
4582 self.assertIs(nowawareplus.tzinfo, tzr)
4594 min = self.theclass(1, 1, 1, tzinfo=FixedOffset(1439, "min"))
4596 tzinfo=FixedOffset(-1439, "max"))
4600 # Different tzinfo, but the same offset
4603 delta = min.replace(tzinfo=tza) - max.replace(tzinfo=tzb)
4608 # Ensure it doesn't require tzinfo (i.e., that this doesn't blow up).
4614 self.assertIs(another.tzinfo, again.tzinfo)
4618 self.assertRaises(TypeError, meth, tzinfo=16)
4624 # We don't know which time zone we're in, and don't have a tzinfo
4632 self.assertIs(now.tzinfo, weirdtz)
4633 utcnow = datetime.utcnow().replace(tzinfo=utc)
4647 # Ensure it doesn't require tzinfo (i.e., that this doesn't blow up).
4653 self.assertIs(another.tzinfo, again.tzinfo)
4657 self.assertRaises(TypeError, meth, ts, tzinfo=16)
4676 self.assertEqual(expected, got.replace(tzinfo=None))
4680 # Ensure it doesn't require tzinfo (i.e., that this doesn't blow up).
4683 # utcnow() doesn't accept a tzinfo argument.
4686 self.assertRaises(TypeError, meth, tzinfo=off42)
4692 # Ensure it doesn't require tzinfo (i.e., that this doesn't blow up).
4695 # utcfromtimestamp() doesn't accept a tzinfo argument.
4698 self.assertRaises(TypeError, meth, ts, tzinfo=off42)
4703 class DST(tzinfo):
4713 d = cls(1, 1, 1, 10, 20, 30, 40, tzinfo=DST(dstvalue))
4726 self.assertRaises(TypeError, cls(1, 1, 1, tzinfo=DST("x")).timetuple)
4729 self.assertEqual(cls(1,1,1, tzinfo=DST(1439)).timetuple().tm_isdst, 1)
4730 self.assertEqual(cls(1,1,1, tzinfo=DST(-1439)).timetuple().tm_isdst, 1)
4733 self.assertRaises(ValueError, cls(1,1,1, tzinfo=DST(1440)).timetuple)
4734 self.assertRaises(ValueError, cls(1,1,1, tzinfo=DST(-1440)).timetuple)
4737 class DST(tzinfo):
4748 cls(1, 1, 1, tzinfo=DST(0)).utcoffset)
4758 d = cls(1, 2, 3, 10, 20, 30, 40, tzinfo=UOFS(-53, dstvalue))
4782 d = cls(1, 2, 3, 10, 20, 30, 40, tzinfo=NOFS())
4786 # Check that bad tzinfo is detected
4790 d = cls(1, 2, 3, 10, 20, 30, 40, tzinfo=BOFS())
4797 dtz = d.replace(tzinfo=tz)
4803 tiny = cls(MINYEAR, 1, 1, 0, 0, 37, tzinfo=UOFS(1439))
4807 huge = cls(MAXYEAR, 12, 31, 23, 59, 37, 999999, tzinfo=UOFS(-1439))
4811 tiny = cls.min.replace(tzinfo=timezone(MINUTE))
4813 huge = cls.max.replace(tzinfo=timezone(-MINUTE))
4826 d = cls(1, 2, 3, 4, 5, 59, us, tzinfo=ofs)
4853 ("tzinfo", zm200)):
4861 # Ensure we can get rid of a tzinfo.
4863 base2 = base.replace(tzinfo=None)
4864 self.assertIsNone(base2.tzinfo)
4868 base3 = base2.replace(tzinfo=z100)
4870 self.assertIs(base.tzinfo, base3.tzinfo)
4883 self.assertIs(dt.tzinfo, f44m)
4884 # Replacing with degenerate tzinfo raises an exception.
4886 # Replacing with same tzinfo makes no change.
4887 x = dt.astimezone(dt.tzinfo)
4888 self.assertIs(x.tzinfo, f44m)
4892 # Replacing with different tzinfo does adjust.
4894 self.assertIs(got.tzinfo, fm5h)
4898 expected = expected.replace(tzinfo=fm5h) # and attach new tzinfo
4902 self.assertIs(got.tzinfo, expected.tzinfo)
4915 dt = self.theclass(2012, 11, 4, 6, 30, tzinfo=timezone.utc)
4919 dt = self.theclass(2012, 11, 4, 5, 30, tzinfo=timezone.utc)
4927 u = datetime(2015, 11, 1, 5, tzinfo=timezone.utc)
4930 self.assertEqual(t.tzinfo, s.tzinfo)
4936 # same tzinfo member.
4937 class OperandDependentOffset(tzinfo):
4946 base = cls(8, 9, 10, 11, 12, 13, 14, tzinfo=OperandDependentOffset())
4956 # OTOH, if the tzinfo members are distinct, utcoffsets aren't
4959 d0 = base.replace(minute=3, tzinfo=OperandDependentOffset())
4960 d1 = base.replace(minute=9, tzinfo=OperandDependentOffset())
4961 d2 = base.replace(minute=11, tzinfo=OperandDependentOffset())
4980 t2 = t2.replace(tzinfo=None)
4982 t2 = t2.replace(tzinfo=FixedOffset(None, ""))
4984 t2 = t2.replace(tzinfo=FixedOffset(0, ""))
4987 # In datetime w/ identical tzinfo objects, utcoffset is ignored.
4988 class Varies(tzinfo):
4996 t1 = t2.replace(tzinfo=v)
4997 t2 = t2.replace(tzinfo=v)
5003 t2 = t2.replace(tzinfo=Varies())
5032 # Pain to set up DST-aware tzinfo classes.
5052 class USTimeZone(tzinfo):
5073 if dt is None or dt.tzinfo is None:
5077 assert dt.tzinfo is self
5089 if start <= dt.replace(tzinfo=None) < end:
5175 dston = self.dston.replace(tzinfo=tz)
5181 dstoff = self.dstoff.replace(tzinfo=tz)
5209 # the "utc" class. This is always true for a fixed-offset tzinfo
5224 fourback = fourback.replace(tzinfo=ninewest)
5233 got = fourback.astimezone(Eastern).replace(tzinfo=None)
5238 sixutc = self.dston.replace(hour=6, tzinfo=utc_real)
5243 got = sixutc.astimezone(Eastern).replace(tzinfo=None)
5260 asutcbase = asutc.replace(tzinfo=utc)
5267 self.assertEqual(astz.replace(tzinfo=None), expected)
5272 class ok(tzinfo):
5276 now = self.theclass.now().replace(tzinfo=utc_real)
5285 # Sometimes blow up. In the following, tzinfo.dst()
5295 dt = self.theclass(2001, 1, 1).replace(tzinfo=utc_real)
5300 now = datetime.utcnow().replace(tzinfo=utc_real)
5301 self.assertRaises(ValueError, Eastern.fromutc, now) # wrong tzinfo
5302 now = now.replace(tzinfo=Eastern) # insert correct tzinfo
5304 self.assertEqual(enow.tzinfo, Eastern) # has right tzinfo member
5319 start = self.dston.replace(hour=4, tzinfo=Eastern)
5320 fstart = start.replace(tzinfo=FEastern)
5333 got = fstart.replace(tzinfo=utc_real).astimezone(FEastern)
5340 start = self.dstoff.replace(hour=4, tzinfo=Eastern)
5341 fstart = start.replace(tzinfo=FEastern)
5352 got = fstart.replace(tzinfo=utc_real).astimezone(FEastern)
5406 tzinfo(),
5439 class tzinfo2(tzinfo):
5446 if dt.tzinfo is not self:
5447 raise ValueError("dt.tzinfo is not self")
5494 if dt is None or dt.tzinfo is None:
5498 assert dt.tzinfo is self
5510 dt = dt.replace(tzinfo=None)
5529 # Europe_Vilnius_1941 tzinfo implementation reproduces the following
5541 class Europe_Vilnius_1941(tzinfo):
5543 return [datetime(1941, 6, 23, 21, tzinfo=self), # Mon Jun 23 21:00:00 1941 UTC
5544 datetime(1941, 6, 23, 22, tzinfo=self)] # Mon Jun 23 22:00:00 1941 UTC
5547 return [datetime(1941, 6, 23, 23, tzinfo=self), # Mon Jun 23 23:00:00 1941 MSK / CEST
5548 datetime(1941, 6, 24, 0, tzinfo=self)] # Mon Jun 24 00:00:00 1941 CEST
5579 assert dt.tzinfo is self
5596 gdt = datetime(1941, 6, 23, 20, 59, 59, tzinfo=timezone.utc)
5603 gdt = datetime(1941, 6, 23, 21, tzinfo=timezone.utc)
5610 gdt = datetime(1941, 6, 23, 22, tzinfo=timezone.utc)
5620 ldt = datetime(1941, 6, 23, 22, 59, 59, tzinfo=Vilnius)
5625 ldt = datetime(1941, 6, 23, 23, 59, 59, tzinfo=Vilnius)
5630 ldt = datetime(1941, 6, 23, 23, 59, 59, tzinfo=Vilnius, fold=1)
5635 ldt = datetime(1941, 6, 24, 0, tzinfo=Vilnius)
5663 t = t.replace(fold=1, tzinfo=Eastern)
5664 dt = dt.replace(fold=1, tzinfo=Eastern)
5665 self.assertEqual(t.replace(tzinfo=None).fold, 1)
5666 self.assertEqual(dt.replace(tzinfo=None).fold, 1)
5747 # Aware instances with fixed offset tzinfo's always have fold=0
5770 dt_summer = datetime(2002, 10, 27, 1, tzinfo=Eastern2) - timedelta.resolution
5771 dt_winter = datetime(2002, 10, 27, 2, tzinfo=Eastern2)
5780 dt = datetime(2002, 10, 27, 1, minute, tzinfo=Eastern2)
5788 dt = datetime(2002, 4, 7, 2, minute, tzinfo=Eastern2)
5797 dt_summer = datetime(2002, 10, 27, 1, tzinfo=Eastern2) - timedelta.resolution
5798 dt_winter = datetime(2002, 10, 27, 2, tzinfo=Eastern2)
5807 u_summer = datetime(2002, 10, 27, 6, tzinfo=Eastern2) - timedelta.resolution
5808 u_winter = datetime(2002, 10, 27, 7, tzinfo=Eastern2)
5817 u = datetime(2002, 10, 27, 5, 30, tzinfo=Eastern2)
5825 u = datetime(2002, 10, 27, 1, 30, tzinfo=Eastern2)
5829 u = datetime(2002, 10, 27, 6, 30, tzinfo=Eastern2)
5834 u = datetime(2002, 4, 7, 2, 0, tzinfo=Eastern2)
5839 t = datetime(2000, 1, 1, tzinfo=Eastern2)
5841 t = datetime(2000, 6, 1, tzinfo=Eastern2)
5845 t_fold = datetime(2002, 10, 27, 1, 45, tzinfo=Eastern2)
5851 t_gap = datetime(2002, 4, 7, 2, 45, tzinfo=Eastern2)
5857 t = datetime(2000, 1, 1, tzinfo=Eastern2)
5859 t_fold = datetime(2002, 10, 27, 1, 45, tzinfo=Eastern2)
5860 t_gap = datetime(2002, 4, 7, 2, 45, tzinfo=Eastern2)
5871 class ZoneInfo(tzinfo):
5948 if dt.tzinfo is not self:
5949 raise ValueError("dt.tzinfo is not self")
6115 self.assertEqual((a.replace(tzinfo=None), a.fold, id(a.tzinfo)),
6116 (b.replace(tzinfo=None), b.fold, id(b.tzinfo)))
6123 ldt = tz.fromutc(udt.replace(tzinfo=tz))
6125 adt = udt.replace(tzinfo=timezone.utc).astimezone(tz)
6128 self.assertEqual(ldt.replace(tzinfo=None), udt + utcoffset)
6131 udt.replace(tzinfo=timezone.utc))
6136 udt = udt.replace(tzinfo=tz)
6145 udt = udt.replace(tzinfo=tz)
6148 adt = udt.replace(tzinfo=timezone.utc).astimezone(tz)
6151 self.assertEqual(ldt.replace(tzinfo=None), udt.replace(tzinfo=None) + utcoffset)
6153 ldt = tz.fromutc(dt.replace(tzinfo=tz)) - shift + x
6160 ldt = tz.fromutc(udt.replace(tzinfo=tz))
6192 tzdt = datetime.fromtimestamp(s, tz).replace(tzinfo=None)
6262 dt1 = datetime(2000, 2, 4, tzinfo=tz_act)
6263 dt2 = datetime(2000, 2, 4, tzinfo=tz_exp)
6268 dt_utc = datetime(2000, 2, 4, 5, tzinfo=timezone.utc)
6310 hour, minute, second, microsecond, tzinfo = \
6317 self.assertIs(tzinfo, d.tzinfo)
6328 hour, minute, second, microsecond, tzinfo = \
6335 self.assertIs(tzinfo, d.tzinfo)
6353 dt1 = datetime(2000, 2, 4, tzinfo=non_utc)
6354 dt2 = datetime(2000, 2, 4, tzinfo=non_utc_exp)
6466 class TZInfoSubclass(tzinfo):
6469 tzi = tzinfo()
6611 dtup, tzinfo, usetz = case
6612 dt_orig = datetime(*dtup, tzinfo=tzinfo)
6615 dt_rt = from_timestamp(ts, tzinfo, usetz, macro)