Apr 16, 2025 · Apr 16, 2025 · Apr 16, 2025 · Apr 16, 2025 · Apr 16, 2025 · Apr 17, 2025
diff --git a/Lib/test/datetimetester.py b/Lib/test/datetimetester.py

                    self.assertEqual(dt_orig, dt_rt)

    def assert_python_ok_in_subinterp(self, script, init='', fini='',
                                      repeat=1, config='isolated'):
    def test_type_check_in_subinterp(self):
        # iOS requires the use of the custom framework loader,
        # not the ExtensionFileLoader.
        if sys.platform == "ios":
            extension_loader = "AppleFrameworkLoader"
        else:
            extension_loader = "ExtensionFileLoader"

        code = textwrap.dedent(f'''
            subinterp_code = """
        script = textwrap.dedent(f"""
            if {_interpreters is None}:
                import _testcapi
                import _testcapi as module
                module.test_datetime_capi()
            else:
                import importlib.machinery
                import importlib.util
                fullname = '_testcapi_datetime'
                origin = importlib.util.find_spec('_testcapi').origin
                loader = importlib.machinery.{extension_loader}(fullname, origin)
                spec = importlib.util.spec_from_loader(fullname, loader)
                _testcapi = importlib.util.module_from_spec(spec)
                spec.loader.exec_module(_testcapi)
            interp_index = $INTERP_INDEX$
            setup = _testcapi.test_datetime_capi_newinterp  # call it if needed
            $SCRIPT$
            """
                module = importlib.util.module_from_spec(spec)
                spec.loader.exec_module(module)

            import _testcapi
            from test import support
            setup = _testcapi.test_datetime_capi_newinterp
            $INIT$

            for idx in range({repeat}):
                subcode = subinterp_code.replace('$INTERP_INDEX$', str(idx))
                if {_interpreters is None}:
                    ret = support.run_in_subinterp(subcode)
                else:
                    import _interpreters
                    config = _interpreters.new_config('{config}').__dict__
                    ret = support.run_in_subinterp_with_config(subcode, **config)
                assert ret == 0
            $FINI$
        ''')
        code = code.replace('$INIT$', init).replace('$FINI$', fini)
        code = code.replace('$SCRIPT$', script)

        res = script_helper.assert_python_ok('-c', code)
        return res

    def test_type_check_in_subinterp(self):
        script = textwrap.dedent(f"""
            def run(type_checker, obj):
                if not type_checker(obj, True):
                    raise TypeError(f'{{type(obj)}} is not C API type')

            setup()
            import _datetime
            run(_testcapi.datetime_check_date,     _datetime.date.today())
            run(_testcapi.datetime_check_datetime, _datetime.datetime.now())
            run(_testcapi.datetime_check_time,     _datetime.time(12, 30))
            run(_testcapi.datetime_check_delta,    _datetime.timedelta(1))
            run(_testcapi.datetime_check_tzinfo,   _datetime.tzinfo())
            """)
        self.assert_python_ok_in_subinterp(script)
        if _interpreters is not None:
            with self.subTest(name := 'legacy'):
                self.assert_python_ok_in_subinterp(script, config=name)
            run(module.datetime_check_date,     _datetime.date.today())
            run(module.datetime_check_datetime, _datetime.datetime.now())
            run(module.datetime_check_time,     _datetime.time(12, 30))
            run(module.datetime_check_delta,    _datetime.timedelta(1))
            run(module.datetime_check_tzinfo,   _datetime.tzinfo())
        """)
        if _interpreters is None:
            ret = support.run_in_subinterp(script)
            self.assertEqual(ret, 0)
        else:
            for name in ('isolated', 'legacy'):
                with self.subTest(name):
                    config = _interpreters.new_config(name).__dict__
                    ret = support.run_in_subinterp_with_config(script, **config)
                    self.assertEqual(ret, 0)


 class ExtensionModuleTests(unittest.TestCase):
        if self.__class__.__name__.endswith('Pure'):
            self.skipTest('Not relevant in pure Python')

    def assert_python_ok_in_subinterp(self, *args, **kwargs):
        return CapiTest.assert_python_ok_in_subinterp(self, *args, **kwargs)

    @support.cpython_only
    def test_gh_120161(self):
        with self.subTest('simple'):
                assert isinstance(_datetime.timezone.utc, _datetime.tzinfo)
                del sys.modules['_datetime']
            """)
        res = script_helper.assert_python_ok('-c', script)
        self.assertFalse(res.err)

    def test_module_free(self):
        script = textwrap.dedent("""
            import sys
            import gc
            import weakref
            ws = weakref.WeakSet()
            for _ in range(3):
                import _datetime
                timedelta = _datetime.timedelta  # static type
                ws.add(_datetime)
                del sys.modules['_datetime']
                del _datetime
                gc.collect()
                assert len(ws) == 1  # only one remains
            """)
        script_helper.assert_python_ok('-c', script)

    @unittest.skipIf(not support.Py_DEBUG, "Debug builds only")
    def test_no_leak(self):
        script = textwrap.dedent("""
            import datetime
            datetime.datetime.strptime('20000101', '%Y%m%d').strftime('%Y%m%d')
            """)
        res = script_helper.assert_python_ok('-X', 'showrefcount', '-c', script)
        self.assertIn(b'[0 refs, 0 blocks]', res.err)

    def test_static_type_on_subinterp(self):
        script = textwrap.dedent("""
            date = _testcapi.get_capi_types()['date']
            date.today
            """)
        with_setup = 'setup()' + script
        with self.subTest('[PyDateTime_IMPORT] main: no, sub: yes'):
            self.assert_python_ok_in_subinterp(with_setup)

        with self.subTest('[PyDateTime_IMPORT] main: yes, sub: yes'):
            # Fails if the setup() means test_datetime_capi() rather than
            # test_datetime_capi_newinterp()
            self.assert_python_ok_in_subinterp(with_setup, 'setup()')
            self.assert_python_ok_in_subinterp('setup()', fini=with_setup)
            self.assert_python_ok_in_subinterp(with_setup, repeat=2)

        with_import = 'import _datetime' + script
        with self.subTest('Explicit import'):
            self.assert_python_ok_in_subinterp(with_import, 'setup()')

        with_import = textwrap.dedent("""
            timedelta = _testcapi.get_capi_types()['timedelta']
            timedelta(days=1)
            """) + script
        with self.subTest('Implicit import'):
            self.assert_python_ok_in_subinterp(with_import, 'setup()')

    def test_static_type_at_shutdown(self):
        # gh-132413
        script = textwrap.dedent("""
            import sys
            import _datetime
            timedelta = _datetime.timedelta

            def gen():
                try:
                    yield
                finally:
                    # Exceptions are ignored here
                    assert not sys.modules
                    td = _datetime.timedelta(days=1)
                    assert td.days == 1
                    td = timedelta(days=1)
                    assert td.days == 1
                    assert not sys.modules

            it = gen()
            next(it)
            """)
        with self.subTest('MainInterpreter'):
            res = script_helper.assert_python_ok('-c', script)
            self.assertFalse(res.err)
        with self.subTest('Subinterpreter'):
            res = self.assert_python_ok_in_subinterp(script)
            self.assertFalse(res.err)

        script = textwrap.dedent("""
            import sys
            timedelta = _testcapi.get_capi_types()['timedelta']

            def gen():
                try:
                    yield
                finally:
                    # Exceptions are ignored here
                    assert not sys.modules
                    td = timedelta(days=1)
                    assert td.days == 1
                    assert not sys.modules

            it = gen()
            next(it)
            """)
        with self.subTest('[PyDateTime_IMPORT] main: yes, sub: no'):
            res = self.assert_python_ok_in_subinterp(script, 'setup()')
            self.assertIn(b'ImportError: sys.meta_path is None', res.err)

        with_import = 'setup()' + script
        with self.subTest('[PyDateTime_IMPORT] main: no, sub: yes'):
            res = self.assert_python_ok_in_subinterp(with_import)
            self.assertFalse(res.err)


 def load_tests(loader, standard_tests, pattern):
    standard_tests.addTest(ZoneInfoCompleteTest())
diff --git a/Lib/test/test_embed.py b/Lib/test/test_embed.py
        out, err = self.run_embedded_interpreter("test_repeated_init_exec", code)
        self.assertEqual(out, '20000101\n' * INIT_LOOPS)

    def test_datetime_capi_at_shutdown(self):
        # gh-132413: datetime module is currently tested in an interp's life.
        # PyDateTime_IMPORT needs to be called at least once after the restart.
        code = textwrap.dedent("""
            import sys
            import _testcapi
            _testcapi.test_datetime_capi_newinterp()
            timedelta = _testcapi.get_capi_types()['timedelta']

            def gen():
                try:
                    yield
                finally:
                    assert not sys.modules
                    res = 0
                    try:
                        timedelta(days=1)
                        res = 1
                    except ImportError:
                        res = 2
                    print(res)

            it = gen()
            next(it)
        """)
        out, err = self.run_embedded_interpreter("test_repeated_init_exec", code)
        self.assertEqual(out, '1\n' * INIT_LOOPS)

    def test_static_types_inherited_slots(self):
        script = textwrap.dedent("""
            import test.support
Original file line number	Diff line number	Diff line change
Expand Up		@@ -7155,73 +7155,48 @@ def test_datetime_from_timestamp(self):

		self.assertEqual(dt_orig, dt_rt)

		def assert_python_ok_in_subinterp(self, script, init='', fini='',
		repeat=1, config='isolated'):
		def test_type_check_in_subinterp(self):
		# iOS requires the use of the custom framework loader,
		# not the ExtensionFileLoader.
		if sys.platform == "ios":
		extension_loader = "AppleFrameworkLoader"
		else:
		extension_loader = "ExtensionFileLoader"

		code = textwrap.dedent(f'''
		subinterp_code = """
		script = textwrap.dedent(f"""
		if {_interpreters is None}:
		import _testcapi
		import _testcapi as module
		module.test_datetime_capi()
		else:
		import importlib.machinery
		import importlib.util
		fullname = '_testcapi_datetime'
		origin = importlib.util.find_spec('_testcapi').origin
		loader = importlib.machinery.{extension_loader}(fullname, origin)
		spec = importlib.util.spec_from_loader(fullname, loader)
		_testcapi = importlib.util.module_from_spec(spec)
		spec.loader.exec_module(_testcapi)
		interp_index = $INTERP_INDEX$
		setup = _testcapi.test_datetime_capi_newinterp # call it if needed
		$SCRIPT$
		"""
		module = importlib.util.module_from_spec(spec)
		spec.loader.exec_module(module)

		import _testcapi
		from test import support
		setup = _testcapi.test_datetime_capi_newinterp
		$INIT$

		for idx in range({repeat}):
		subcode = subinterp_code.replace('$INTERP_INDEX$', str(idx))
		if {_interpreters is None}:
		ret = support.run_in_subinterp(subcode)
		else:
		import _interpreters
		config = _interpreters.new_config('{config}').__dict__
		ret = support.run_in_subinterp_with_config(subcode, **config)
		assert ret == 0
		$FINI$
		''')
		code = code.replace('$INIT$', init).replace('$FINI$', fini)
		code = code.replace('$SCRIPT$', script)

		res = script_helper.assert_python_ok('-c', code)
		return res

		def test_type_check_in_subinterp(self):
		script = textwrap.dedent(f"""
		def run(type_checker, obj):
		if not type_checker(obj, True):
		raise TypeError(f'{{type(obj)}} is not C API type')

		setup()
		import _datetime
		run(_testcapi.datetime_check_date, _datetime.date.today())
		run(_testcapi.datetime_check_datetime, _datetime.datetime.now())
		run(_testcapi.datetime_check_time, _datetime.time(12, 30))
		run(_testcapi.datetime_check_delta, _datetime.timedelta(1))
		run(_testcapi.datetime_check_tzinfo, _datetime.tzinfo())
		""")
		self.assert_python_ok_in_subinterp(script)
		if _interpreters is not None:
		with self.subTest(name := 'legacy'):
		self.assert_python_ok_in_subinterp(script, config=name)
		run(module.datetime_check_date, _datetime.date.today())
		run(module.datetime_check_datetime, _datetime.datetime.now())
		run(module.datetime_check_time, _datetime.time(12, 30))
		run(module.datetime_check_delta, _datetime.timedelta(1))
		run(module.datetime_check_tzinfo, _datetime.tzinfo())
		""")
		if _interpreters is None:
		ret = support.run_in_subinterp(script)
		self.assertEqual(ret, 0)
		else:
		for name in ('isolated', 'legacy'):
		with self.subTest(name):
		config = _interpreters.new_config(name).__dict__
		ret = support.run_in_subinterp_with_config(script, **config)
		self.assertEqual(ret, 0)


		class ExtensionModuleTests(unittest.TestCase):
Expand All		@@ -7230,9 +7205,6 @@ def setUp(self):
		if self.__class__.__name__.endswith('Pure'):
		self.skipTest('Not relevant in pure Python')

		def assert_python_ok_in_subinterp(self, args, *kwargs):
		return CapiTest.assert_python_ok_in_subinterp(self, args, *kwargs)

		@support.cpython_only
		def test_gh_120161(self):
		with self.subTest('simple'):
Expand DownExpand Up		@@ -7298,117 +7270,8 @@ def test_update_type_cache(self):
		assert isinstance(_datetime.timezone.utc, _datetime.tzinfo)
		del sys.modules['_datetime']
		""")
		res = script_helper.assert_python_ok('-c', script)
		self.assertFalse(res.err)

		def test_module_free(self):
		script = textwrap.dedent("""
		import sys
		import gc
		import weakref
		ws = weakref.WeakSet()
		for _ in range(3):
		import _datetime
		timedelta = _datetime.timedelta # static type
		ws.add(_datetime)
		del sys.modules['_datetime']
		del _datetime
		gc.collect()
		assert len(ws) == 1 # only one remains
		""")
		script_helper.assert_python_ok('-c', script)

		@unittest.skipIf(not support.Py_DEBUG, "Debug builds only")
		def test_no_leak(self):
		script = textwrap.dedent("""
		import datetime
		datetime.datetime.strptime('20000101', '%Y%m%d').strftime('%Y%m%d')
		""")
		res = script_helper.assert_python_ok('-X', 'showrefcount', '-c', script)
		self.assertIn(b'[0 refs, 0 blocks]', res.err)

		def test_static_type_on_subinterp(self):
		script = textwrap.dedent("""
		date = _testcapi.get_capi_types()['date']
		date.today
		""")
		with_setup = 'setup()' + script
		with self.subTest('[PyDateTime_IMPORT] main: no, sub: yes'):
		self.assert_python_ok_in_subinterp(with_setup)

		with self.subTest('[PyDateTime_IMPORT] main: yes, sub: yes'):
		# Fails if the setup() means test_datetime_capi() rather than
		# test_datetime_capi_newinterp()
		self.assert_python_ok_in_subinterp(with_setup, 'setup()')
		self.assert_python_ok_in_subinterp('setup()', fini=with_setup)
		self.assert_python_ok_in_subinterp(with_setup, repeat=2)

		with_import = 'import _datetime' + script
		with self.subTest('Explicit import'):
		self.assert_python_ok_in_subinterp(with_import, 'setup()')

		with_import = textwrap.dedent("""
		timedelta = _testcapi.get_capi_types()['timedelta']
		timedelta(days=1)
		""") + script
		with self.subTest('Implicit import'):
		self.assert_python_ok_in_subinterp(with_import, 'setup()')

		def test_static_type_at_shutdown(self):
		# gh-132413
		script = textwrap.dedent("""
		import sys
		import _datetime
		timedelta = _datetime.timedelta

		def gen():
		try:
		yield
		finally:
		# Exceptions are ignored here
		assert not sys.modules
		td = _datetime.timedelta(days=1)
		assert td.days == 1
		td = timedelta(days=1)
		assert td.days == 1
		assert not sys.modules

		it = gen()
		next(it)
		""")
		with self.subTest('MainInterpreter'):
		res = script_helper.assert_python_ok('-c', script)
		self.assertFalse(res.err)
		with self.subTest('Subinterpreter'):
		res = self.assert_python_ok_in_subinterp(script)
		self.assertFalse(res.err)

		script = textwrap.dedent("""
		import sys
		timedelta = _testcapi.get_capi_types()['timedelta']

		def gen():
		try:
		yield
		finally:
		# Exceptions are ignored here
		assert not sys.modules
		td = timedelta(days=1)
		assert td.days == 1
		assert not sys.modules

		it = gen()
		next(it)
		""")
		with self.subTest('[PyDateTime_IMPORT] main: yes, sub: no'):
		res = self.assert_python_ok_in_subinterp(script, 'setup()')
		self.assertIn(b'ImportError: sys.meta_path is None', res.err)

		with_import = 'setup()' + script
		with self.subTest('[PyDateTime_IMPORT] main: no, sub: yes'):
		res = self.assert_python_ok_in_subinterp(with_import)
		self.assertFalse(res.err)


		def load_tests(loader, standard_tests, pattern):
		standard_tests.addTest(ZoneInfoCompleteTest())
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -440,34 +440,6 @@ def test_datetime_reset_strptime(self):
		out, err = self.run_embedded_interpreter("test_repeated_init_exec", code)
		self.assertEqual(out, '20000101\n' * INIT_LOOPS)

		def test_datetime_capi_at_shutdown(self):
		# gh-132413: datetime module is currently tested in an interp's life.
		# PyDateTime_IMPORT needs to be called at least once after the restart.
		code = textwrap.dedent("""
		import sys
		import _testcapi
		_testcapi.test_datetime_capi_newinterp()
		timedelta = _testcapi.get_capi_types()['timedelta']

		def gen():
		try:
		yield
		finally:
		assert not sys.modules
		res = 0
		try:
		timedelta(days=1)
		res = 1
		except ImportError:
		res = 2
		print(res)

		it = gen()
		next(it)
		""")
		out, err = self.run_embedded_interpreter("test_repeated_init_exec", code)
		self.assertEqual(out, '1\n' * INIT_LOOPS)

		def test_static_types_inherited_slots(self):
		script = textwrap.dedent("""
		import test.support
Expand Down