diff --git a/Lib/test/.ruff.toml b/Lib/test/.ruff.toml index 7b46139f786..b5be4c3afaf 100644 --- a/Lib/test/.ruff.toml +++ b/Lib/test/.ruff.toml @@ -14,6 +14,9 @@ extend-exclude = [ # New grammar constructions may not yet be recognized by Ruff, # and tests re-use the same names as only the grammar is being checked. "test_grammar.py", + # Lazy import syntax (PEP 810) is not yet supported by Ruff + "test_import/data/lazy_imports/*.py", + "test_import/data/lazy_imports/**/*.py", ] [lint] diff --git a/Lib/test/exception_hierarchy.txt b/Lib/test/exception_hierarchy.txt index f2649aa2d41..98a5e950602 100644 --- a/Lib/test/exception_hierarchy.txt +++ b/Lib/test/exception_hierarchy.txt @@ -14,6 +14,7 @@ BaseException ├── EOFError ├── ExceptionGroup [BaseExceptionGroup] ├── ImportError + │ └── ImportCycleError │ └── ModuleNotFoundError ├── LookupError │ ├── IndexError diff --git a/Lib/test/test_ast/data/ast_repr.txt b/Lib/test/test_ast/data/ast_repr.txt index 1c1985519cd..cc6accd766b 100644 --- a/Lib/test/test_ast/data/ast_repr.txt +++ b/Lib/test/test_ast/data/ast_repr.txt @@ -69,10 +69,14 @@ Module(body=[Try(body=[Pass()], handlers=[ExceptHandler(type=Name(...), name='ex Module(body=[TryStar(body=[Pass()], handlers=[ExceptHandler(type=Name(...), name='exc', body=[Pass(...)])], orelse=[Pass()], finalbody=[Pass()])], type_ignores=[]) Module(body=[Assert(test=Name(id='v', ctx=Load(...)), msg=None)], type_ignores=[]) Module(body=[Assert(test=Name(id='v', ctx=Load(...)), msg=Constant(value='message', kind=None))], type_ignores=[]) -Module(body=[Import(names=[alias(name='sys', asname=None)])], type_ignores=[]) -Module(body=[Import(names=[alias(name='foo', asname='bar')])], type_ignores=[]) -Module(body=[ImportFrom(module='sys', names=[alias(name='x', asname='y')], level=0)], type_ignores=[]) -Module(body=[ImportFrom(module='sys', names=[alias(name='v', asname=None)], level=0)], type_ignores=[]) +Module(body=[Import(names=[alias(name='sys', asname=None)], is_lazy=0)], type_ignores=[]) +Module(body=[Import(names=[alias(name='foo', asname='bar')], is_lazy=0)], type_ignores=[]) +Module(body=[ImportFrom(module='sys', names=[alias(name='x', asname='y')], level=0, is_lazy=0)], type_ignores=[]) +Module(body=[ImportFrom(module='sys', names=[alias(name='v', asname=None)], level=0, is_lazy=0)], type_ignores=[]) +Module(body=[Import(names=[alias(name='sys', asname=None)], is_lazy=1)], type_ignores=[]) +Module(body=[Import(names=[alias(name='foo', asname='bar')], is_lazy=1)], type_ignores=[]) +Module(body=[ImportFrom(module='sys', names=[alias(name='x', asname='y')], level=0, is_lazy=1)], type_ignores=[]) +Module(body=[ImportFrom(module='sys', names=[alias(name='v', asname=None)], level=0, is_lazy=1)], type_ignores=[]) Module(body=[Global(names=['v'])], type_ignores=[]) Module(body=[Expr(value=Constant(value=1, kind=None))], type_ignores=[]) Module(body=[Pass()], type_ignores=[]) diff --git a/Lib/test/test_ast/snippets.py b/Lib/test/test_ast/snippets.py index b76f98901d2..a565ed10f8b 100644 --- a/Lib/test/test_ast/snippets.py +++ b/Lib/test/test_ast/snippets.py @@ -118,6 +118,12 @@ # ImportFrom "from sys import x as y", "from sys import v", + # Lazy Import + "lazy import sys", + "lazy import foo as bar", + # Lazy ImportFrom + "lazy from sys import x as y", + "lazy from sys import v", # Global "global v", # Expr @@ -460,10 +466,14 @@ def main(): ('Module', [('TryStar', (1, 0, 7, 6), [('Pass', (2, 2, 2, 6))], [('ExceptHandler', (3, 0, 4, 6), ('Name', (3, 8, 3, 17), 'Exception', ('Load',)), 'exc', [('Pass', (4, 2, 4, 6))])], [('Pass', (5, 7, 5, 11))], [('Pass', (7, 2, 7, 6))])], []), ('Module', [('Assert', (1, 0, 1, 8), ('Name', (1, 7, 1, 8), 'v', ('Load',)), None)], []), ('Module', [('Assert', (1, 0, 1, 19), ('Name', (1, 7, 1, 8), 'v', ('Load',)), ('Constant', (1, 10, 1, 19), 'message', None))], []), -('Module', [('Import', (1, 0, 1, 10), [('alias', (1, 7, 1, 10), 'sys', None)])], []), -('Module', [('Import', (1, 0, 1, 17), [('alias', (1, 7, 1, 17), 'foo', 'bar')])], []), -('Module', [('ImportFrom', (1, 0, 1, 22), 'sys', [('alias', (1, 16, 1, 22), 'x', 'y')], 0)], []), -('Module', [('ImportFrom', (1, 0, 1, 17), 'sys', [('alias', (1, 16, 1, 17), 'v', None)], 0)], []), +('Module', [('Import', (1, 0, 1, 10), [('alias', (1, 7, 1, 10), 'sys', None)], 0)], []), +('Module', [('Import', (1, 0, 1, 17), [('alias', (1, 7, 1, 17), 'foo', 'bar')], 0)], []), +('Module', [('ImportFrom', (1, 0, 1, 22), 'sys', [('alias', (1, 16, 1, 22), 'x', 'y')], 0, 0)], []), +('Module', [('ImportFrom', (1, 0, 1, 17), 'sys', [('alias', (1, 16, 1, 17), 'v', None)], 0, 0)], []), +('Module', [('Import', (1, 0, 1, 15), [('alias', (1, 12, 1, 15), 'sys', None)], 1)], []), +('Module', [('Import', (1, 0, 1, 22), [('alias', (1, 12, 1, 22), 'foo', 'bar')], 1)], []), +('Module', [('ImportFrom', (1, 0, 1, 27), 'sys', [('alias', (1, 21, 1, 27), 'x', 'y')], 0, 1)], []), +('Module', [('ImportFrom', (1, 0, 1, 22), 'sys', [('alias', (1, 21, 1, 22), 'v', None)], 0, 1)], []), ('Module', [('Global', (1, 0, 1, 8), ['v'])], []), ('Module', [('Expr', (1, 0, 1, 1), ('Constant', (1, 0, 1, 1), 1, None))], []), ('Module', [('Pass', (1, 0, 1, 4))], []), diff --git a/Lib/test/test_ast/test_ast.py b/Lib/test/test_ast/test_ast.py index c5f42cb7888..f29f98beb2d 100644 --- a/Lib/test/test_ast/test_ast.py +++ b/Lib/test/test_ast/test_ast.py @@ -1701,8 +1701,8 @@ def check_text(code, empty, full, **kwargs): check_text( "import _ast as ast; from module import sub", - empty="Module(body=[Import(names=[alias(name='_ast', asname='ast')]), ImportFrom(module='module', names=[alias(name='sub')], level=0)])", - full="Module(body=[Import(names=[alias(name='_ast', asname='ast')]), ImportFrom(module='module', names=[alias(name='sub')], level=0)], type_ignores=[])", + empty="Module(body=[Import(names=[alias(name='_ast', asname='ast')], is_lazy=0), ImportFrom(module='module', names=[alias(name='sub')], level=0, is_lazy=0)])", + full="Module(body=[Import(names=[alias(name='_ast', asname='ast')], is_lazy=0), ImportFrom(module='module', names=[alias(name='sub')], level=0, is_lazy=0)], type_ignores=[])", ) def test_copy_location(self): diff --git a/Lib/test/test_capi/test_config.py b/Lib/test/test_capi/test_config.py index b04d0923926..f10ad50d3be 100644 --- a/Lib/test/test_capi/test_config.py +++ b/Lib/test/test_capi/test_config.py @@ -62,6 +62,7 @@ def test_config_get(self): ("int_max_str_digits", int, None), ("interactive", bool, None), ("isolated", bool, None), + ("lazy_imports", int, None), ("malloc_stats", bool, None), ("pymalloc_hugepages", bool, None), ("module_search_paths", list[str], "path"), diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py index 8529afaa3f5..cefd64ddfe8 100644 --- a/Lib/test/test_dis.py +++ b/Lib/test/test_dis.py @@ -292,7 +292,7 @@ def wrap_func_w_kwargs(): 1 LOAD_SMALL_INT 0 LOAD_CONST 1 (('*',)) - IMPORT_NAME 0 (math) + IMPORT_NAME 2 (math + eager) CALL_INTRINSIC_1 2 (INTRINSIC_IMPORT_STAR) POP_TOP LOAD_CONST 2 (None) diff --git a/Lib/test/test_embed.py b/Lib/test/test_embed.py index 29b1249b10d..35246d7c484 100644 --- a/Lib/test/test_embed.py +++ b/Lib/test/test_embed.py @@ -635,6 +635,7 @@ class InitConfigTests(EmbeddingTestsMixin, unittest.TestCase): 'tracemalloc': 0, 'perf_profiling': 0, 'import_time': 0, + 'lazy_imports': -1, 'thread_inherit_context': DEFAULT_THREAD_INHERIT_CONTEXT, 'context_aware_warnings': DEFAULT_CONTEXT_AWARE_WARNINGS, 'code_debug_ranges': True, diff --git a/Lib/test/test_import/data/lazy_imports/basic2.py b/Lib/test/test_import/data/lazy_imports/basic2.py new file mode 100644 index 00000000000..f93ec89d5ab --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/basic2.py @@ -0,0 +1,4 @@ +def f(): + pass + +x = 42 diff --git a/Lib/test/test_import/data/lazy_imports/basic_compatibility_mode.py b/Lib/test/test_import/data/lazy_imports/basic_compatibility_mode.py new file mode 100644 index 00000000000..5076fa4894e --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/basic_compatibility_mode.py @@ -0,0 +1,2 @@ +__lazy_modules__ = ['test.test_import.data.lazy_imports.basic2'] +import test.test_import.data.lazy_imports.basic2 diff --git a/Lib/test/test_import/data/lazy_imports/basic_compatibility_mode_relative.py b/Lib/test/test_import/data/lazy_imports/basic_compatibility_mode_relative.py new file mode 100644 index 00000000000..e37759348f3 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/basic_compatibility_mode_relative.py @@ -0,0 +1,2 @@ +__lazy_modules__ = ['test.test_import.data.lazy_imports.basic2'] +lazy from .basic2 import f diff --git a/Lib/test/test_import/data/lazy_imports/basic_compatibility_mode_used.py b/Lib/test/test_import/data/lazy_imports/basic_compatibility_mode_used.py new file mode 100644 index 00000000000..64f36645f68 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/basic_compatibility_mode_used.py @@ -0,0 +1,3 @@ +__lazy_modules__ = ['test.test_import.data.lazy_imports.basic2'] +import test.test_import.data.lazy_imports.basic2 +test.test_import.data.lazy_imports.basic2.f() diff --git a/Lib/test/test_import/data/lazy_imports/basic_dir.py b/Lib/test/test_import/data/lazy_imports/basic_dir.py new file mode 100644 index 00000000000..ca9e29d3d99 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/basic_dir.py @@ -0,0 +1,2 @@ +lazy import test.test_import.data.lazy_imports.basic2 +x = dir() diff --git a/Lib/test/test_import/data/lazy_imports/basic_from_unused.py b/Lib/test/test_import/data/lazy_imports/basic_from_unused.py new file mode 100644 index 00000000000..686caa86a6c --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/basic_from_unused.py @@ -0,0 +1 @@ +lazy from test.test_import.data.lazy_imports import basic2 diff --git a/Lib/test/test_import/data/lazy_imports/basic_unused.py b/Lib/test/test_import/data/lazy_imports/basic_unused.py new file mode 100644 index 00000000000..bf8ae4613e4 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/basic_unused.py @@ -0,0 +1 @@ +lazy import test.test_import.data.lazy_imports.basic2 diff --git a/Lib/test/test_import/data/lazy_imports/basic_used.py b/Lib/test/test_import/data/lazy_imports/basic_used.py new file mode 100644 index 00000000000..84e354750f8 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/basic_used.py @@ -0,0 +1,3 @@ +lazy import test.test_import.data.lazy_imports.basic2 as basic2 + +basic2.f() diff --git a/Lib/test/test_import/data/lazy_imports/broken_attr_module.py b/Lib/test/test_import/data/lazy_imports/broken_attr_module.py new file mode 100644 index 00000000000..a60bca2bad0 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/broken_attr_module.py @@ -0,0 +1,3 @@ +# Module that exists but doesn't have expected attributes +x = 42 +# No 'nonexistent_attr' here diff --git a/Lib/test/test_import/data/lazy_imports/broken_module.py b/Lib/test/test_import/data/lazy_imports/broken_module.py new file mode 100644 index 00000000000..b49d4a4a15f --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/broken_module.py @@ -0,0 +1,2 @@ +# Module that raises an error during import +raise ValueError("This module always fails to import") diff --git a/Lib/test/test_import/data/lazy_imports/compatibility_mode_func.py b/Lib/test/test_import/data/lazy_imports/compatibility_mode_func.py new file mode 100644 index 00000000000..307338a0886 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/compatibility_mode_func.py @@ -0,0 +1,5 @@ +__lazy_modules__ = ['test.test_import.data.lazy_imports.basic2'] +def f(): + import test.test_import.data.lazy_imports.basic2 + +f() diff --git a/Lib/test/test_import/data/lazy_imports/compatibility_mode_try_except.py b/Lib/test/test_import/data/lazy_imports/compatibility_mode_try_except.py new file mode 100644 index 00000000000..6d54e69a9a4 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/compatibility_mode_try_except.py @@ -0,0 +1,5 @@ +__lazy_modules__ = ['test.test_import.data.lazy_imports.basic2'] +try: + import test.test_import.data.lazy_imports.basic2 +except: + pass diff --git a/Lib/test/test_import/data/lazy_imports/dunder_lazy_import.py b/Lib/test/test_import/data/lazy_imports/dunder_lazy_import.py new file mode 100644 index 00000000000..1a8a19c3c90 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/dunder_lazy_import.py @@ -0,0 +1 @@ +basic = __lazy_import__('test.test_import.data.lazy_imports.basic2') diff --git a/Lib/test/test_import/data/lazy_imports/dunder_lazy_import_builtins.py b/Lib/test/test_import/data/lazy_imports/dunder_lazy_import_builtins.py new file mode 100644 index 00000000000..f1fed0fc317 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/dunder_lazy_import_builtins.py @@ -0,0 +1,14 @@ +import sys + +def myimport(*args): + return sys.modules[__name__] + + +new_globals = dict(globals()) +new_globals["__builtins__"] = { + "__import__": myimport, +} +basic2 = 42 +basic = __lazy_import__("test.test_import.data.lazy_imports.basic2", + globals=new_globals) +basic diff --git a/Lib/test/test_import/data/lazy_imports/dunder_lazy_import_used.py b/Lib/test/test_import/data/lazy_imports/dunder_lazy_import_used.py new file mode 100644 index 00000000000..2432ca17b16 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/dunder_lazy_import_used.py @@ -0,0 +1,3 @@ +basic = __lazy_import__('test.test_import.data.lazy_imports', + fromlist=("basic2", )) +basic diff --git a/Lib/test/test_import/data/lazy_imports/eager_import_func.py b/Lib/test/test_import/data/lazy_imports/eager_import_func.py new file mode 100644 index 00000000000..89e643ac183 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/eager_import_func.py @@ -0,0 +1,3 @@ +def f(): + import test.test_import.data.lazy_imports.basic2 as basic2 + return basic2 diff --git a/Lib/test/test_import/data/lazy_imports/global_filter.py b/Lib/test/test_import/data/lazy_imports/global_filter.py new file mode 100644 index 00000000000..72cb5f2ef5a --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/global_filter.py @@ -0,0 +1,10 @@ +import sys + +def filter(module_name, imported_name, from_list): + assert module_name == __name__ + assert imported_name == "test.test_import.data.lazy_imports.basic2" + return False + +sys.set_lazy_imports_filter(filter) + +lazy import test.test_import.data.lazy_imports.basic2 as basic2 diff --git a/Lib/test/test_import/data/lazy_imports/global_filter_from.py b/Lib/test/test_import/data/lazy_imports/global_filter_from.py new file mode 100644 index 00000000000..733839d9c1e --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/global_filter_from.py @@ -0,0 +1,11 @@ +import importlib + +def filter(module_name, imported_name, from_list): + assert module_name == __name__ + assert imported_name == "test.test_import.data.lazy_imports.basic2" + assert from_list == ['f'] + return False + +importlib.set_lazy_imports(None, filter) + +lazy from import test.test_import.data.lazy_imports.basic2 import f diff --git a/Lib/test/test_import/data/lazy_imports/global_filter_from_true.py b/Lib/test/test_import/data/lazy_imports/global_filter_from_true.py new file mode 100644 index 00000000000..c019f1ae811 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/global_filter_from_true.py @@ -0,0 +1,11 @@ +import importlib + +def filter(module_name, imported_name, from_list): + assert module_name == __name__ + assert imported_name == "test.test_import.data.lazy_imports.basic2" + assert from_list == ['f'] + return True + +importlib.set_lazy_imports(None, filter) + +lazy from import test.test_import.data.lazy_imports.basic2 import f diff --git a/Lib/test/test_import/data/lazy_imports/global_filter_true.py b/Lib/test/test_import/data/lazy_imports/global_filter_true.py new file mode 100644 index 00000000000..4881b30fb02 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/global_filter_true.py @@ -0,0 +1,11 @@ +import sys + +def filter(module_name, imported_name, from_list): + assert module_name == __name__ + assert imported_name == "test.test_import.data.lazy_imports.basic2" + return True + +sys.set_lazy_imports("normal") +sys.set_lazy_imports_filter(filter) + +lazy import test.test_import.data.lazy_imports.basic2 as basic2 diff --git a/Lib/test/test_import/data/lazy_imports/global_off.py b/Lib/test/test_import/data/lazy_imports/global_off.py new file mode 100644 index 00000000000..4f202744a9e --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/global_off.py @@ -0,0 +1,5 @@ +import sys + +sys.set_lazy_imports("none") + +lazy import test.test_import.data.lazy_imports.basic2 as basic2 diff --git a/Lib/test/test_import/data/lazy_imports/global_on.py b/Lib/test/test_import/data/lazy_imports/global_on.py new file mode 100644 index 00000000000..3f8e1d2aa01 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/global_on.py @@ -0,0 +1,5 @@ +import sys + +sys.set_lazy_imports("all") + +import test.test_import.data.lazy_imports.basic2 as basic2 diff --git a/Lib/test/test_import/data/lazy_imports/globals_access.py b/Lib/test/test_import/data/lazy_imports/globals_access.py new file mode 100644 index 00000000000..c12c6a029c2 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/globals_access.py @@ -0,0 +1,9 @@ +# Test that globals() returns lazy proxy objects without reifying +lazy import test.test_import.data.lazy_imports.basic2 as basic2 + +def get_from_globals(): + g = globals() + return g['basic2'] + +def get_direct(): + return basic2 diff --git a/Lib/test/test_import/data/lazy_imports/lazy_class_body.py b/Lib/test/test_import/data/lazy_imports/lazy_class_body.py new file mode 100644 index 00000000000..e154b78f6cd --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/lazy_class_body.py @@ -0,0 +1,3 @@ +# SyntaxError: lazy import inside class body is not allowed +class Foo: + lazy import json diff --git a/Lib/test/test_import/data/lazy_imports/lazy_compat_from.py b/Lib/test/test_import/data/lazy_imports/lazy_compat_from.py new file mode 100644 index 00000000000..f887f47b92c --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/lazy_compat_from.py @@ -0,0 +1,6 @@ +# Test __lazy_modules__ with from imports +__lazy_modules__ = ['test.test_import.data.lazy_imports.basic2'] +from test.test_import.data.lazy_imports.basic2 import x, f + +def get_x(): + return x diff --git a/Lib/test/test_import/data/lazy_imports/lazy_future_import.py b/Lib/test/test_import/data/lazy_imports/lazy_future_import.py new file mode 100644 index 00000000000..8bd258b76b4 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/lazy_future_import.py @@ -0,0 +1 @@ +lazy from __future__ import annotations diff --git a/Lib/test/test_import/data/lazy_imports/lazy_get_value.py b/Lib/test/test_import/data/lazy_imports/lazy_get_value.py new file mode 100644 index 00000000000..0ff572fa1e3 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/lazy_get_value.py @@ -0,0 +1,7 @@ +lazy import test.test_import.data.lazy_imports.basic2 as basic2 + +def f(): + x = globals() + return x['basic2'].resolve() + +f() diff --git a/Lib/test/test_import/data/lazy_imports/lazy_import_func.py b/Lib/test/test_import/data/lazy_imports/lazy_import_func.py new file mode 100644 index 00000000000..af758b51127 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/lazy_import_func.py @@ -0,0 +1,2 @@ +def f(): + lazy import foo diff --git a/Lib/test/test_import/data/lazy_imports/lazy_import_pkg.py b/Lib/test/test_import/data/lazy_imports/lazy_import_pkg.py new file mode 100644 index 00000000000..79aa9a56739 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/lazy_import_pkg.py @@ -0,0 +1,2 @@ +lazy import test.test_import.data.lazy_imports.pkg.bar +x = test.test_import.data.lazy_imports.pkg.bar.f diff --git a/Lib/test/test_import/data/lazy_imports/lazy_try_except.py b/Lib/test/test_import/data/lazy_imports/lazy_try_except.py new file mode 100644 index 00000000000..e58d1f929ca --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/lazy_try_except.py @@ -0,0 +1,4 @@ +try: + lazy import foo +except: + pass diff --git a/Lib/test/test_import/data/lazy_imports/lazy_try_except_from.py b/Lib/test/test_import/data/lazy_imports/lazy_try_except_from.py new file mode 100644 index 00000000000..8c97553f486 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/lazy_try_except_from.py @@ -0,0 +1,4 @@ +try: + lazy from foo import bar +except: + pass diff --git a/Lib/test/test_import/data/lazy_imports/lazy_try_except_from_star.py b/Lib/test/test_import/data/lazy_imports/lazy_try_except_from_star.py new file mode 100644 index 00000000000..b2370eaae77 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/lazy_try_except_from_star.py @@ -0,0 +1 @@ +lazy from foo import * diff --git a/Lib/test/test_import/data/lazy_imports/lazy_with.py b/Lib/test/test_import/data/lazy_imports/lazy_with.py new file mode 100644 index 00000000000..b383879936a --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/lazy_with.py @@ -0,0 +1,3 @@ +import contextlib +with contextlib.nullcontext(): + lazy import test.test_import.data.lazy_imports.basic2 diff --git a/Lib/test/test_import/data/lazy_imports/lazy_with_from.py b/Lib/test/test_import/data/lazy_imports/lazy_with_from.py new file mode 100644 index 00000000000..7936326a9e3 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/lazy_with_from.py @@ -0,0 +1,3 @@ +import contextlib +with contextlib.nullcontext(): + lazy import test.test_import.data.lazy_imports.basic2 as basic2 diff --git a/Lib/test/test_import/data/lazy_imports/modules_dict.py b/Lib/test/test_import/data/lazy_imports/modules_dict.py new file mode 100644 index 00000000000..327f866398c --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/modules_dict.py @@ -0,0 +1,5 @@ +lazy import test.test_import.data.lazy_imports.basic2 as basic2 + +import sys +mod = sys.modules[__name__] +x = mod.__dict__ diff --git a/Lib/test/test_import/data/lazy_imports/modules_getattr.py b/Lib/test/test_import/data/lazy_imports/modules_getattr.py new file mode 100644 index 00000000000..ae1d4bb3f97 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/modules_getattr.py @@ -0,0 +1,5 @@ +lazy import test.test_import.data.lazy_imports.basic2 as basic2 + +import sys +mod = sys.modules[__name__] +x = mod.basic2 diff --git a/Lib/test/test_import/data/lazy_imports/modules_getattr_other.py b/Lib/test/test_import/data/lazy_imports/modules_getattr_other.py new file mode 100644 index 00000000000..e4d83e6336d --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/modules_getattr_other.py @@ -0,0 +1,5 @@ +lazy import test.test_import.data.lazy_imports.basic2 as basic2 + +import sys +mod = sys.modules[__name__] +x = mod.__name__ diff --git a/Lib/test/test_import/data/lazy_imports/multi_from_import.py b/Lib/test/test_import/data/lazy_imports/multi_from_import.py new file mode 100644 index 00000000000..96dc9757500 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/multi_from_import.py @@ -0,0 +1,5 @@ +# Test that lazy from import with multiple names only reifies accessed names +lazy from test.test_import.data.lazy_imports.basic2 import f, x + +def get_globals(): + return globals() diff --git a/Lib/test/test_import/data/lazy_imports/pkg/__init__.py b/Lib/test/test_import/data/lazy_imports/pkg/__init__.py new file mode 100644 index 00000000000..2d76abaa89f --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/pkg/__init__.py @@ -0,0 +1 @@ +x = 42 diff --git a/Lib/test/test_import/data/lazy_imports/pkg/b.py b/Lib/test/test_import/data/lazy_imports/pkg/b.py new file mode 100644 index 00000000000..a266b7c7c0d --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/pkg/b.py @@ -0,0 +1,2 @@ +def foo(): + return 'foo' diff --git a/Lib/test/test_import/data/lazy_imports/pkg/bar.py b/Lib/test/test_import/data/lazy_imports/pkg/bar.py new file mode 100644 index 00000000000..b8d8b60b886 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/pkg/bar.py @@ -0,0 +1,2 @@ +print("BAR_MODULE_LOADED") +def f(): pass diff --git a/Lib/test/test_import/data/lazy_imports/pkg/c.py b/Lib/test/test_import/data/lazy_imports/pkg/c.py new file mode 100644 index 00000000000..0bb03119864 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/pkg/c.py @@ -0,0 +1,4 @@ +lazy from . import b, x + +def get_globals(): + return globals() diff --git a/Lib/test/test_import/data/lazy_imports/relative_lazy.py b/Lib/test/test_import/data/lazy_imports/relative_lazy.py new file mode 100644 index 00000000000..6273d3883ab --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/relative_lazy.py @@ -0,0 +1,5 @@ +# Test relative imports with lazy keyword +lazy from . import basic2 + +def get_basic2(): + return basic2 diff --git a/Lib/test/test_import/data/lazy_imports/relative_lazy_from.py b/Lib/test/test_import/data/lazy_imports/relative_lazy_from.py new file mode 100644 index 00000000000..1bae2d6853d --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/relative_lazy_from.py @@ -0,0 +1,8 @@ +# Test relative from imports with lazy keyword +lazy from .basic2 import x, f + +def get_x(): + return x + +def get_f(): + return f diff --git a/Lib/test/test_import/data/lazy_imports/try_except_eager.py b/Lib/test/test_import/data/lazy_imports/try_except_eager.py new file mode 100644 index 00000000000..4cdaa9a9b48 --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/try_except_eager.py @@ -0,0 +1,4 @@ +try: + import test.test_import.data.lazy_imports.basic2 +except: + pass diff --git a/Lib/test/test_import/data/lazy_imports/try_except_eager_from.py b/Lib/test/test_import/data/lazy_imports/try_except_eager_from.py new file mode 100644 index 00000000000..6eadaaa71ca --- /dev/null +++ b/Lib/test/test_import/data/lazy_imports/try_except_eager_from.py @@ -0,0 +1,4 @@ +try: + from test.test_import.data.lazy_imports.basic2 import f +except: + pass diff --git a/Lib/test/test_import/test_lazy_imports.py b/Lib/test/test_import/test_lazy_imports.py new file mode 100644 index 00000000000..1193af95890 --- /dev/null +++ b/Lib/test/test_import/test_lazy_imports.py @@ -0,0 +1,1662 @@ +"""Tests for PEP 810 lazy imports.""" + +import io +import dis +import subprocess +import sys +import textwrap +import threading +import types +import unittest + +try: + import _testcapi +except ImportError: + _testcapi = None + + +class LazyImportTests(unittest.TestCase): + """Tests for basic lazy import functionality.""" + + def tearDown(self): + """Clean up any test modules from sys.modules.""" + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + sys.lazy_modules.clear() + + def test_basic_unused(self): + """Lazy imported module should not be loaded if never accessed.""" + import test.test_import.data.lazy_imports.basic_unused + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + self.assertIn("test.test_import.data.lazy_imports", sys.lazy_modules) + self.assertEqual(sys.lazy_modules["test.test_import.data.lazy_imports"], {"basic2"}) + + def test_sys_lazy_modules(self): + try: + import test.test_import.data.lazy_imports.basic_from_unused + except ImportError as e: + self.fail('lazy import failed') + + self.assertFalse("test.test_import.data.lazy_imports.basic2" in sys.modules) + self.assertIn("test.test_import.data.lazy_imports", sys.lazy_modules) + self.assertEqual(sys.lazy_modules["test.test_import.data.lazy_imports"], {"basic2"}) + test.test_import.data.lazy_imports.basic_from_unused.basic2 + self.assertNotIn("test.test_import.data", sys.lazy_modules) + + def test_basic_unused_use_externally(self): + """Lazy import should load module when accessed from outside.""" + from test.test_import.data.lazy_imports import basic_unused + + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + x = basic_unused.test.test_import.data.lazy_imports.basic2 + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_basic_from_unused_use_externally(self): + """Lazy 'from' import should load when accessed from outside.""" + from test.test_import.data.lazy_imports import basic_from_unused + + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + x = basic_from_unused.basic2 + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_basic_unused_dir(self): + """dir() on module should not trigger lazy import reification.""" + import test.test_import.data.lazy_imports.basic_unused + + x = dir(test.test_import.data.lazy_imports.basic_unused) + self.assertIn("test", x) + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_basic_dir(self): + """dir() at module scope should not trigger lazy import reification.""" + from test.test_import.data.lazy_imports import basic_dir + + self.assertIn("test", basic_dir.x) + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_basic_used(self): + """Lazy import should load when accessed within the module.""" + import test.test_import.data.lazy_imports.basic_used + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + +class GlobalLazyImportModeTests(unittest.TestCase): + """Tests for sys.set_lazy_imports() global mode control.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_global_off(self): + """Mode 'none' should disable lazy imports entirely.""" + import test.test_import.data.lazy_imports.global_off + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_global_on(self): + """Mode 'all' should make regular imports lazy.""" + import test.test_import.data.lazy_imports.global_on + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_global_filter(self): + """Filter returning False should prevent lazy loading.""" + import test.test_import.data.lazy_imports.global_filter + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_global_filter_true(self): + """Filter returning True should allow lazy loading.""" + import test.test_import.data.lazy_imports.global_filter_true + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_global_filter_from(self): + """Filter should work with 'from' imports.""" + import test.test_import.data.lazy_imports.global_filter + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_global_filter_from_true(self): + """Filter returning True should allow lazy 'from' imports.""" + import test.test_import.data.lazy_imports.global_filter_true + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + +class CompatibilityModeTests(unittest.TestCase): + """Tests for __lazy_modules__ compatibility mode.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_compatibility_mode(self): + """__lazy_modules__ should enable lazy imports for listed modules.""" + import test.test_import.data.lazy_imports.basic_compatibility_mode + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_compatibility_mode_used(self): + """Using a lazy import from __lazy_modules__ should load the module.""" + import test.test_import.data.lazy_imports.basic_compatibility_mode_used + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_compatibility_mode_func(self): + """Imports inside functions should be eager even in compatibility mode.""" + import test.test_import.data.lazy_imports.compatibility_mode_func + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_compatibility_mode_try_except(self): + """Imports in try/except should be eager even in compatibility mode.""" + import test.test_import.data.lazy_imports.compatibility_mode_try_except + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_compatibility_mode_relative(self): + """__lazy_modules__ should work with relative imports.""" + import test.test_import.data.lazy_imports.basic_compatibility_mode_relative + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + +class ModuleIntrospectionTests(unittest.TestCase): + """Tests for module dict and getattr behavior with lazy imports.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_modules_dict(self): + """Accessing module.__dict__ should not trigger reification.""" + import test.test_import.data.lazy_imports.modules_dict + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_modules_getattr(self): + """Module __getattr__ for lazy import name should trigger reification.""" + import test.test_import.data.lazy_imports.modules_getattr + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_modules_getattr_other(self): + """Module __getattr__ for other names should not trigger reification.""" + import test.test_import.data.lazy_imports.modules_getattr_other + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + +class LazyImportTypeTests(unittest.TestCase): + """Tests for the LazyImportType and its resolve() method.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_lazy_value_resolve(self): + """resolve() method should force the lazy import to load.""" + import test.test_import.data.lazy_imports.lazy_get_value + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_lazy_import_type_exposed(self): + """LazyImportType should be exposed in types module.""" + self.assertHasAttr(types, 'LazyImportType') + self.assertEqual(types.LazyImportType.__name__, 'lazy_import') + + def test_lazy_import_type_cant_construct(self): + """LazyImportType should not be directly constructible.""" + self.assertRaises(TypeError, types.LazyImportType, {}, "module") + + +class SyntaxRestrictionTests(unittest.TestCase): + """Tests for syntax restrictions on lazy imports.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_lazy_try_except(self): + """lazy import inside try/except should raise SyntaxError.""" + with self.assertRaises(SyntaxError): + import test.test_import.data.lazy_imports.lazy_try_except + + def test_lazy_try_except_from(self): + """lazy from import inside try/except should raise SyntaxError.""" + with self.assertRaises(SyntaxError): + import test.test_import.data.lazy_imports.lazy_try_except_from + + def test_lazy_try_except_from_star(self): + """lazy from import * should raise SyntaxError.""" + with self.assertRaises(SyntaxError): + import test.test_import.data.lazy_imports.lazy_try_except_from_star + + def test_lazy_future_import(self): + """lazy from __future__ import should raise SyntaxError.""" + with self.assertRaises(SyntaxError) as cm: + import test.test_import.data.lazy_imports.lazy_future_import + # Check we highlight 'lazy' (column offset 0, end offset 4) + self.assertEqual(cm.exception.offset, 1) + self.assertEqual(cm.exception.end_offset, 5) + + def test_lazy_import_func(self): + """lazy import inside function should raise SyntaxError.""" + with self.assertRaises(SyntaxError): + import test.test_import.data.lazy_imports.lazy_import_func + + def test_lazy_import_exec_in_function(self): + """lazy import via exec() inside a function should raise SyntaxError.""" + # exec() inside a function creates a non-module-level context + # where lazy imports are not allowed + def f(): + exec("lazy import json") + + with self.assertRaises(SyntaxError) as cm: + f() + self.assertIn("only allowed at module level", str(cm.exception)) + + def test_lazy_import_exec_at_module_level(self): + """lazy import via exec() at module level should work.""" + # exec() at module level (globals == locals) should allow lazy imports + code = textwrap.dedent(""" + import sys + exec("lazy import json") + # Should be lazy - not loaded yet + assert 'json' not in sys.modules + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + +class EagerImportInLazyModeTests(unittest.TestCase): + """Tests for imports that should remain eager even in lazy mode.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_try_except_eager(self): + """Imports in try/except should be eager even with mode='all'.""" + sys.set_lazy_imports("all") + import test.test_import.data.lazy_imports.try_except_eager + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_try_except_eager_from(self): + """From imports in try/except should be eager even with mode='all'.""" + sys.set_lazy_imports("all") + import test.test_import.data.lazy_imports.try_except_eager_from + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_eager_import_func(self): + """Imports inside functions should return modules, not proxies.""" + sys.set_lazy_imports("all") + import test.test_import.data.lazy_imports.eager_import_func + + f = test.test_import.data.lazy_imports.eager_import_func.f + self.assertEqual(type(f()), type(sys)) + + +class WithStatementTests(unittest.TestCase): + """Tests for lazy imports in with statement context.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_lazy_with(self): + """lazy import with 'with' statement should work.""" + import test.test_import.data.lazy_imports.lazy_with + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_lazy_with_from(self): + """lazy from import with 'with' statement should work.""" + import test.test_import.data.lazy_imports.lazy_with_from + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + +class PackageTests(unittest.TestCase): + """Tests for lazy imports with packages.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_lazy_import_pkg(self): + """lazy import of package submodule should load the package.""" + import test.test_import.data.lazy_imports.lazy_import_pkg + + self.assertIn("test.test_import.data.lazy_imports.pkg", sys.modules) + self.assertIn("test.test_import.data.lazy_imports.pkg.bar", sys.modules) + + def test_lazy_import_pkg_cross_import(self): + """Cross-imports within package should preserve lazy imports.""" + import test.test_import.data.lazy_imports.pkg.c + + self.assertIn("test.test_import.data.lazy_imports.pkg", sys.modules) + self.assertIn("test.test_import.data.lazy_imports.pkg.c", sys.modules) + self.assertNotIn("test.test_import.data.lazy_imports.pkg.b", sys.modules) + + g = test.test_import.data.lazy_imports.pkg.c.get_globals() + self.assertEqual(type(g["x"]), int) + self.assertEqual(type(g["b"]), types.LazyImportType) + + +class DunderLazyImportTests(unittest.TestCase): + """Tests for __lazy_import__ builtin function.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_dunder_lazy_import(self): + """__lazy_import__ should create lazy import proxy.""" + import test.test_import.data.lazy_imports.dunder_lazy_import + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_dunder_lazy_import_used(self): + """Using __lazy_import__ result should trigger module load.""" + import test.test_import.data.lazy_imports.dunder_lazy_import_used + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_dunder_lazy_import_builtins(self): + """__lazy_import__ should use module's __builtins__ for __import__.""" + from test.test_import.data.lazy_imports import dunder_lazy_import_builtins + + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + self.assertEqual(dunder_lazy_import_builtins.basic.basic2, 42) + + +class SysLazyImportsAPITests(unittest.TestCase): + """Tests for sys lazy imports API functions.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_set_lazy_imports_requires_string(self): + """set_lazy_imports should reject non-string arguments.""" + with self.assertRaises(TypeError): + sys.set_lazy_imports(True) + with self.assertRaises(TypeError): + sys.set_lazy_imports(None) + with self.assertRaises(TypeError): + sys.set_lazy_imports(1) + + def test_set_lazy_imports_rejects_invalid_mode(self): + """set_lazy_imports should reject invalid mode strings.""" + with self.assertRaises(ValueError): + sys.set_lazy_imports("invalid") + with self.assertRaises(ValueError): + sys.set_lazy_imports("on") + with self.assertRaises(ValueError): + sys.set_lazy_imports("off") + + def test_get_lazy_imports_returns_string(self): + """get_lazy_imports should return string modes.""" + sys.set_lazy_imports("normal") + self.assertEqual(sys.get_lazy_imports(), "normal") + + sys.set_lazy_imports("all") + self.assertEqual(sys.get_lazy_imports(), "all") + + sys.set_lazy_imports("none") + self.assertEqual(sys.get_lazy_imports(), "none") + + def test_get_lazy_imports_filter_default(self): + """get_lazy_imports_filter should return None by default.""" + sys.set_lazy_imports_filter(None) + self.assertIsNone(sys.get_lazy_imports_filter()) + + def test_set_and_get_lazy_imports_filter(self): + """set/get_lazy_imports_filter should round-trip filter function.""" + def my_filter(name): + return name.startswith("test.") + + sys.set_lazy_imports_filter(my_filter) + self.assertIs(sys.get_lazy_imports_filter(), my_filter) + + def test_lazy_modules_attribute_is_set(self): + """sys.lazy_modules should be a set per PEP 810.""" + self.assertIsInstance(sys.lazy_modules, dict) + + def test_lazy_modules_tracks_lazy_imports(self): + """sys.lazy_modules should track lazily imported module names.""" + code = textwrap.dedent(""" + import sys + initial_count = len(sys.lazy_modules) + import test.test_import.data.lazy_imports.basic_unused + assert "test.test_import.data.lazy_imports" in sys.lazy_modules + assert sys.lazy_modules["test.test_import.data.lazy_imports"] == {"basic2"} + assert len(sys.lazy_modules) > initial_count + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + +class ErrorHandlingTests(unittest.TestCase): + """Tests for error handling during lazy import reification. + + PEP 810: Errors during reification should show exception chaining with + both the lazy import definition location and the access location. + """ + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_import_error_shows_chained_traceback(self): + """ImportError during reification should chain to show both definition and access.""" + # Errors at reification must show where the lazy import was defined + # AND where the access happened, per PEP 810 "Reification" section + code = textwrap.dedent(""" + import sys + lazy import test.test_import.data.lazy_imports.nonexistent_module + + try: + x = test.test_import.data.lazy_imports.nonexistent_module + except ImportError as e: + # Should have __cause__ showing the original error + # The exception chain shows both where import was defined and where access happened + assert e.__cause__ is not None, "Expected chained exception" + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_attribute_error_on_from_import_shows_chained_traceback(self): + """Accessing missing attribute from lazy from-import should chain errors.""" + # Tests 'lazy from module import nonexistent' behavior + code = textwrap.dedent(""" + import sys + lazy from test.test_import.data.lazy_imports.basic2 import nonexistent_name + + try: + x = nonexistent_name + except ImportError as e: + # PEP 810: Enhanced error reporting through exception chaining + assert e.__cause__ is not None, "Expected chained exception" + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_reification_retries_on_failure(self): + """Failed reification should allow retry on subsequent access. + + PEP 810: "If reification fails, the lazy object is not reified or replaced. + Subsequent uses of the lazy object will re-try the reification." + """ + code = textwrap.dedent(""" + import sys + import types + + lazy import test.test_import.data.lazy_imports.broken_module + + # First access - should fail + try: + x = test.test_import.data.lazy_imports.broken_module + except ValueError: + pass + + # The lazy object should still be a lazy proxy (not reified) + g = globals() + lazy_obj = g['test'] + # The root 'test' binding should still allow retry + # Second access - should also fail (retry the import) + try: + x = test.test_import.data.lazy_imports.broken_module + except ValueError: + print("OK - retry worked") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_error_during_module_execution_propagates(self): + """Errors in module code during reification should propagate correctly.""" + # Module that raises during import should propagate with chaining + code = textwrap.dedent(""" + import sys + lazy import test.test_import.data.lazy_imports.broken_module + + try: + _ = test.test_import.data.lazy_imports.broken_module + print("FAIL - should have raised") + except ValueError as e: + # The ValueError from the module should be the cause + if "always fails" in str(e) or (e.__cause__ and "always fails" in str(e.__cause__)): + print("OK") + else: + print(f"FAIL - wrong error: {e}") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + +class GlobalsAndDictTests(unittest.TestCase): + """Tests for globals() and __dict__ behavior with lazy imports. + + PEP 810: "Calling globals() or accessing a module's __dict__ does not trigger + reification – they return the module's dictionary, and accessing lazy objects + through that dictionary still returns lazy proxy objects." + """ + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_globals_returns_lazy_proxy_when_accessed_from_function(self): + """globals() accessed from a function should return lazy proxy without reification. + + Note: At module level, accessing globals()['name'] triggers LOAD_NAME which + automatically resolves lazy imports. Inside a function, accessing globals()['name'] + uses BINARY_SUBSCR which returns the lazy proxy without resolution. + """ + code = textwrap.dedent(""" + import sys + import types + + lazy from test.test_import.data.lazy_imports.basic2 import x + + # Check that module is not yet loaded + assert 'test.test_import.data.lazy_imports.basic2' not in sys.modules + + def check_lazy(): + # Access through globals() from inside a function + g = globals() + lazy_obj = g['x'] + return type(lazy_obj) is types.LazyImportType + + # Inside function, should get lazy proxy + is_lazy = check_lazy() + assert is_lazy, "Expected LazyImportType from function scope" + + # Module should STILL not be loaded + assert 'test.test_import.data.lazy_imports.basic2' not in sys.modules + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_globals_dict_access_returns_lazy_proxy_inline(self): + """Accessing globals()['name'] inline should return lazy proxy. + + Note: Assigning g['name'] to a local variable at module level triggers + reification due to STORE_NAME bytecode. Inline access preserves laziness. + """ + code = textwrap.dedent(""" + import sys + import types + lazy import json + # Inline access without assignment to local variable preserves lazy proxy + assert type(globals()['json']) is types.LazyImportType + assert 'json' not in sys.modules + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_module_dict_returns_lazy_proxy_without_reifying(self): + """module.__dict__ access should not trigger reification.""" + import test.test_import.data.lazy_imports.globals_access + + # Module not loaded yet via direct dict access + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + # Access via get_from_globals should return lazy proxy + lazy_obj = test.test_import.data.lazy_imports.globals_access.get_from_globals() + self.assertEqual(type(lazy_obj), types.LazyImportType) + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_direct_access_triggers_reification(self): + """Direct name access (not through globals()) should trigger reification.""" + import test.test_import.data.lazy_imports.globals_access + + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + # Direct access should reify + result = test.test_import.data.lazy_imports.globals_access.get_direct() + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_resolve_method_forces_reification(self): + """Calling resolve() on lazy proxy should force reification. + + Note: Must access lazy proxy from within a function to avoid automatic + reification by LOAD_NAME at module level. + """ + code = textwrap.dedent(""" + import sys + import types + + lazy from test.test_import.data.lazy_imports.basic2 import x + + assert 'test.test_import.data.lazy_imports.basic2' not in sys.modules + + def test_resolve(): + g = globals() + lazy_obj = g['x'] + assert type(lazy_obj) is types.LazyImportType, f"Expected lazy proxy, got {type(lazy_obj)}" + + resolved = lazy_obj.resolve() + + # Now module should be loaded + assert 'test.test_import.data.lazy_imports.basic2' in sys.modules + assert resolved == 42 # x is 42 in basic2.py + return True + + assert test_resolve() + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_add_lazy_to_globals(self): + code = textwrap.dedent(""" + import sys + import types + + lazy from test.test_import.data.lazy_imports import basic2 + + assert 'test.test_import.data.lazy_imports.basic2' not in sys.modules + + class C: pass + sneaky = C() + sneaky.x = 1 + + def f(): + t = 0 + for _ in range(5): + t += sneaky.x + return t + + f() + globals()["sneaky"] = globals()["basic2"] + assert f() == 210 + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + +class MultipleNameFromImportTests(unittest.TestCase): + """Tests for lazy from ... import with multiple names. + + PEP 810: "When using lazy from ... import, each imported name is bound to a + lazy proxy object. The first access to any of these names triggers loading + of the entire module and reifies only that specific name to its actual value. + Other names remain as lazy proxies until they are accessed." + """ + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_accessing_one_name_leaves_others_as_proxies(self): + """Accessing one name from multi-name import should leave others lazy.""" + code = textwrap.dedent(""" + import sys + import types + + lazy from test.test_import.data.lazy_imports.basic2 import f, x + + # Neither should be loaded yet + assert 'test.test_import.data.lazy_imports.basic2' not in sys.modules + + g = globals() + assert type(g['f']) is types.LazyImportType + assert type(g['x']) is types.LazyImportType + + # Access 'x' - this loads the module and reifies only 'x' + value = x + assert value == 42 + + # Module is now loaded + assert 'test.test_import.data.lazy_imports.basic2' in sys.modules + + # 'x' should be reified (int), 'f' should still be lazy proxy + assert type(g['x']) is int, f"Expected int, got {type(g['x'])}" + assert type(g['f']) is types.LazyImportType, f"Expected LazyImportType, got {type(g['f'])}" + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_all_names_reified_after_all_accessed(self): + """All names should be reified after each is accessed.""" + code = textwrap.dedent(""" + import sys + import types + + lazy from test.test_import.data.lazy_imports.basic2 import f, x + + g = globals() + + # Access both + _ = x + _ = f + + # Both should be reified now + assert type(g['x']) is int + assert callable(g['f']) + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + +class SysLazyModulesTrackingTests(unittest.TestCase): + """Tests for sys.lazy_modules tracking behavior. + + PEP 810: "When the module is reified, it's removed from sys.lazy_modules" + """ + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_module_added_to_lazy_modules_on_lazy_import(self): + """Module should be added to sys.lazy_modules when lazily imported.""" + # PEP 810 states lazy_modules tracks modules that have been lazily imported + # Note: The current implementation keeps modules in lazy_modules even after + # reification (primarily for diagnostics and introspection) + code = textwrap.dedent(""" + import sys + + initial_count = len(sys.lazy_modules) + + lazy import test.test_import.data.lazy_imports.basic2 + + # Should be in lazy_modules after lazy import + assert "test.test_import.data.lazy_imports" in sys.lazy_modules + assert sys.lazy_modules["test.test_import.data.lazy_imports"] == {"basic2"} + assert len(sys.lazy_modules) > initial_count + + # Trigger reification + _ = test.test_import.data.lazy_imports.basic2.x + + # Module should still be tracked (for diagnostics per PEP 810) + assert "test.test_import.data.lazy_imports" not in sys.lazy_modules + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_lazy_modules_is_per_interpreter(self): + """Each interpreter should have independent sys.lazy_modules.""" + # Basic test that sys.lazy_modules exists and is a set + self.assertIsInstance(sys.lazy_modules, dict) + + +class CommandLineAndEnvVarTests(unittest.TestCase): + """Tests for command-line and environment variable control. + + PEP 810: The global lazy imports flag can be controlled through: + - The -X lazy_imports= command-line option + - The PYTHON_LAZY_IMPORTS= environment variable + """ + + def test_cli_lazy_imports_all_makes_regular_imports_lazy(self): + """-X lazy_imports=all should make all imports potentially lazy.""" + code = textwrap.dedent(""" + import sys + # In 'all' mode, regular imports become lazy + import json + # json should not be in sys.modules yet (lazy) + # Actually accessing it triggers reification + if 'json' not in sys.modules: + print("LAZY") + else: + print("EAGER") + """) + result = subprocess.run( + [sys.executable, "-X", "lazy_imports=all", "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stderr: {result.stderr}") + self.assertIn("LAZY", result.stdout) + + def test_cli_lazy_imports_none_forces_all_imports_eager(self): + """-X lazy_imports=none should force all imports to be eager.""" + code = textwrap.dedent(""" + import sys + # Even explicit lazy imports should be eager in 'none' mode + lazy import json + if 'json' in sys.modules: + print("EAGER") + else: + print("LAZY") + """) + result = subprocess.run( + [sys.executable, "-X", "lazy_imports=none", "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stderr: {result.stderr}") + self.assertIn("EAGER", result.stdout) + + def test_cli_lazy_imports_normal_respects_lazy_keyword_only(self): + """-X lazy_imports=normal should respect lazy keyword only.""" + # Note: Use test modules instead of stdlib modules to avoid + # modules already loaded by the interpreter startup + code = textwrap.dedent(""" + import sys + import test.test_import.data.lazy_imports.basic2 # Should be eager + lazy import test.test_import.data.lazy_imports.pkg.b # Should be lazy + + eager_loaded = 'test.test_import.data.lazy_imports.basic2' in sys.modules + lazy_loaded = 'test.test_import.data.lazy_imports.pkg.b' in sys.modules + + if eager_loaded and not lazy_loaded: + print("OK") + else: + print(f"FAIL: eager={eager_loaded}, lazy={lazy_loaded}") + """) + result = subprocess.run( + [sys.executable, "-X", "lazy_imports=normal", "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_env_var_lazy_imports_all_enables_global_lazy(self): + """PYTHON_LAZY_IMPORTS=all should enable global lazy imports.""" + code = textwrap.dedent(""" + import sys + import json + if 'json' not in sys.modules: + print("LAZY") + else: + print("EAGER") + """) + import os + env = os.environ.copy() + env["PYTHON_LAZY_IMPORTS"] = "all" + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True, + env=env + ) + self.assertEqual(result.returncode, 0, f"stderr: {result.stderr}") + self.assertIn("LAZY", result.stdout) + + def test_env_var_lazy_imports_none_disables_all_lazy(self): + """PYTHON_LAZY_IMPORTS=none should disable all lazy imports.""" + code = textwrap.dedent(""" + import sys + lazy import json + if 'json' in sys.modules: + print("EAGER") + else: + print("LAZY") + """) + import os + env = os.environ.copy() + env["PYTHON_LAZY_IMPORTS"] = "none" + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True, + env=env + ) + self.assertEqual(result.returncode, 0, f"stderr: {result.stderr}") + self.assertIn("EAGER", result.stdout) + + def test_cli_overrides_env_var(self): + """Command-line option should take precedence over environment variable.""" + # PEP 810: -X lazy_imports takes precedence over PYTHON_LAZY_IMPORTS + code = textwrap.dedent(""" + import sys + lazy import json + if 'json' in sys.modules: + print("EAGER") + else: + print("LAZY") + """) + import os + env = os.environ.copy() + env["PYTHON_LAZY_IMPORTS"] = "all" # env says all + result = subprocess.run( + [sys.executable, "-X", "lazy_imports=none", "-c", code], # CLI says none + capture_output=True, + text=True, + env=env + ) + self.assertEqual(result.returncode, 0, f"stderr: {result.stderr}") + # CLI should win - imports should be eager + self.assertIn("EAGER", result.stdout) + + def test_sys_set_lazy_imports_overrides_cli(self): + """sys.set_lazy_imports() should take precedence over CLI option.""" + code = textwrap.dedent(""" + import sys + sys.set_lazy_imports("none") # Override CLI + lazy import json + if 'json' in sys.modules: + print("EAGER") + else: + print("LAZY") + """) + result = subprocess.run( + [sys.executable, "-X", "lazy_imports=all", "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stderr: {result.stderr}") + self.assertIn("EAGER", result.stdout) + + +class FilterFunctionSignatureTests(unittest.TestCase): + """Tests for the filter function signature per PEP 810. + + PEP 810: func(importer: str, name: str, fromlist: tuple[str, ...] | None) -> bool + """ + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_filter_receives_correct_arguments_for_import(self): + """Filter should receive (importer, name, fromlist=None) for 'import x'.""" + code = textwrap.dedent(""" + import sys + + received_args = [] + + def my_filter(importer, name, fromlist): + received_args.append((importer, name, fromlist)) + return True + + sys.set_lazy_imports_filter(my_filter) + + lazy import json + + assert len(received_args) == 1, f"Expected 1 call, got {len(received_args)}" + importer, name, fromlist = received_args[0] + assert name == "json", f"Expected name='json', got {name!r}" + assert fromlist is None, f"Expected fromlist=None, got {fromlist!r}" + assert isinstance(importer, str), f"Expected str importer, got {type(importer)}" + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_filter_receives_fromlist_for_from_import(self): + """Filter should receive fromlist tuple for 'from x import y, z'.""" + code = textwrap.dedent(""" + import sys + + received_args = [] + + def my_filter(importer, name, fromlist): + received_args.append((importer, name, fromlist)) + return True + + sys.set_lazy_imports_filter(my_filter) + + lazy from json import dumps, loads + + assert len(received_args) == 1, f"Expected 1 call, got {len(received_args)}" + importer, name, fromlist = received_args[0] + assert name == "json", f"Expected name='json', got {name!r}" + assert fromlist == ("dumps", "loads"), f"Expected ('dumps', 'loads'), got {fromlist!r}" + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_filter_returning_false_forces_eager_import(self): + """Filter returning False should make import eager.""" + code = textwrap.dedent(""" + import sys + + def deny_filter(importer, name, fromlist): + return False + + sys.set_lazy_imports_filter(deny_filter) + + lazy import json + + # Should be eager due to filter + if 'json' in sys.modules: + print("EAGER") + else: + print("LAZY") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stderr: {result.stderr}") + self.assertIn("EAGER", result.stdout) + + +class AdditionalSyntaxRestrictionTests(unittest.TestCase): + """Additional syntax restriction tests per PEP 810.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_lazy_import_inside_class_raises_syntax_error(self): + """lazy import inside class body should raise SyntaxError.""" + # PEP 810: "The soft keyword is only allowed at the global (module) level, + # not inside functions, class bodies, try blocks, or import *" + with self.assertRaises(SyntaxError): + import test.test_import.data.lazy_imports.lazy_class_body + + +class MixedLazyEagerImportTests(unittest.TestCase): + """Tests for mixing lazy and eager imports of the same module. + + PEP 810: "If module foo is imported both lazily and eagerly in the same + program, the eager import takes precedence and both bindings resolve to + the same module object." + """ + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_eager_import_before_lazy_resolves_to_same_module(self): + """Eager import before lazy should make lazy resolve to same module.""" + code = textwrap.dedent(""" + import sys + import json # Eager import first + + lazy import json as lazy_json # Lazy import same module + + # lazy_json should resolve to the same object + assert json is lazy_json, "Lazy and eager imports should resolve to same module" + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_lazy_import_before_eager_resolves_to_same_module(self): + """Lazy import followed by eager should both point to same module.""" + code = textwrap.dedent(""" + import sys + + lazy import json as lazy_json + + # Lazy not loaded yet + assert 'json' not in sys.modules + + import json # Eager import triggers load + + # Both should be the same object + assert json is lazy_json + print("OK") + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + +class RelativeImportTests(unittest.TestCase): + """Tests for relative imports with lazy keyword.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_relative_lazy_import(self): + """lazy from . import submodule should work.""" + from test.test_import.data.lazy_imports import relative_lazy + + # basic2 should not be loaded yet + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + # Access triggers reification + result = relative_lazy.get_basic2() + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + def test_relative_lazy_from_import(self): + """lazy from .module import name should work.""" + from test.test_import.data.lazy_imports import relative_lazy_from + + # basic2 should not be loaded yet + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + # Access triggers reification + result = relative_lazy_from.get_x() + self.assertEqual(result, 42) + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + +class LazyModulesCompatibilityFromImportTests(unittest.TestCase): + """Tests for __lazy_modules__ with from imports. + + PEP 810: "When a module is made lazy this way, from-imports using that + module are also lazy" + """ + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_lazy_modules_makes_from_imports_lazy(self): + """__lazy_modules__ should make from imports of listed modules lazy.""" + from test.test_import.data.lazy_imports import lazy_compat_from + + # basic2 should not be loaded yet because it's in __lazy_modules__ + self.assertNotIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + # Access triggers reification + result = lazy_compat_from.get_x() + self.assertEqual(result, 42) + self.assertIn("test.test_import.data.lazy_imports.basic2", sys.modules) + + +class ImportStateAtReificationTests(unittest.TestCase): + """Tests for import system state at reification time. + + PEP 810: "Reification still calls __import__ to resolve the import, which uses + the state of the import system (e.g. sys.path, sys.meta_path, sys.path_hooks + and __import__) at reification time, not the state when the lazy import + statement was evaluated." + """ + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_sys_path_at_reification_time_is_used(self): + """sys.path changes after lazy import should affect reification.""" + code = textwrap.dedent(""" + import sys + import tempfile + import os + + # Create a temporary module + with tempfile.TemporaryDirectory() as tmpdir: + mod_path = os.path.join(tmpdir, "dynamic_test_module.py") + with open(mod_path, "w") as f: + f.write("VALUE = 'from_temp_dir'\\n") + + # Lazy import before adding to path + lazy import dynamic_test_module + + # Module cannot be found yet + try: + _ = dynamic_test_module + print("FAIL - should not find module") + except ModuleNotFoundError: + pass + + # Now add temp dir to path + sys.path.insert(0, tmpdir) + + # Now reification should succeed using current sys.path + assert dynamic_test_module.VALUE == 'from_temp_dir' + print("OK") + + sys.path.remove(tmpdir) + """) + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + +class ThreadSafetyTests(unittest.TestCase): + """Tests for thread-safety of lazy imports.""" + + def tearDown(self): + for key in list(sys.modules.keys()): + if key.startswith('test.test_import.data.lazy_imports'): + del sys.modules[key] + + sys.set_lazy_imports_filter(None) + sys.set_lazy_imports("normal") + + def test_concurrent_lazy_import_reification(self): + """Multiple threads racing to reify the same lazy import should succeed.""" + from test.test_import.data.lazy_imports import basic_unused + + num_threads = 10 + results = [None] * num_threads + errors = [] + barrier = threading.Barrier(num_threads) + + def access_lazy_import(idx): + try: + barrier.wait() + module = basic_unused.test.test_import.data.lazy_imports.basic2 + results[idx] = module + except Exception as e: + errors.append((idx, e)) + + threads = [ + threading.Thread(target=access_lazy_import, args=(i,)) + for i in range(num_threads) + ] + + for t in threads: + t.start() + for t in threads: + t.join() + + self.assertEqual(errors, [], f"Errors occurred: {errors}") + self.assertTrue(all(r is not None for r in results)) + first_module = results[0] + for r in results[1:]: + self.assertIs(r, first_module) + + def test_concurrent_reification_multiple_modules(self): + """Multiple threads reifying different lazy imports concurrently.""" + code = textwrap.dedent(""" + import sys + import threading + + sys.set_lazy_imports("all") + + lazy import json + lazy import os + lazy import io + lazy import re + + num_threads = 8 + results = {} + errors = [] + barrier = threading.Barrier(num_threads) + + def access_modules(idx): + try: + barrier.wait() + mods = [json, os, io, re] + results[idx] = [type(m).__name__ for m in mods] + except Exception as e: + errors.append((idx, e)) + + threads = [ + threading.Thread(target=access_modules, args=(i,)) + for i in range(num_threads) + ] + + for t in threads: + t.start() + for t in threads: + t.join() + + assert not errors, f"Errors: {errors}" + for idx, mods in results.items(): + assert all(m == 'module' for m in mods), f"Thread {idx} got: {mods}" + + print("OK") + """) + + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_concurrent_lazy_modules_set_updates(self): + """Multiple threads creating lazy imports should safely update sys.lazy_modules.""" + code = textwrap.dedent(""" + import sys + import threading + + num_threads = 16 + iterations = 50 + errors = [] + barrier = threading.Barrier(num_threads) + + def create_lazy_imports(idx): + try: + barrier.wait() + for i in range(iterations): + exec(f"lazy import json as json_{idx}_{i}", globals()) + exec(f"lazy import os as os_{idx}_{i}", globals()) + except Exception as e: + errors.append((idx, e)) + + threads = [ + threading.Thread(target=create_lazy_imports, args=(i,)) + for i in range(num_threads) + ] + + for t in threads: + t.start() + for t in threads: + t.join() + + assert not errors, f"Errors: {errors}" + assert isinstance(sys.lazy_modules, dict), "sys.lazy_modules is not a dict" + print("OK") + """) + + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_concurrent_reification_same_module_high_contention(self): + """High contention: many threads reifying the exact same lazy import.""" + code = textwrap.dedent(""" + import sys + import threading + import types + + sys.set_lazy_imports("all") + + lazy import json + + num_threads = 20 + results = [None] * num_threads + errors = [] + barrier = threading.Barrier(num_threads) + + def access_json(idx): + try: + barrier.wait() + for _ in range(100): + _ = json.dumps + _ = json.loads + results[idx] = json + except Exception as e: + errors.append((idx, e)) + + threads = [ + threading.Thread(target=access_json, args=(i,)) + for i in range(num_threads) + ] + + for t in threads: + t.start() + for t in threads: + t.join() + + assert not errors, f"Errors: {errors}" + assert all(r is not None for r in results), "Some threads got None" + first = results[0] + assert all(r is first for r in results), "Inconsistent module objects" + assert not isinstance(first, types.LazyImportType), "Got lazy import instead of module" + print("OK") + """) + + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + def test_concurrent_reification_with_module_attribute_access(self): + """Threads racing to reify and immediately access module attributes.""" + code = textwrap.dedent(""" + import sys + import threading + + sys.set_lazy_imports("all") + + lazy import collections + lazy import functools + lazy import itertools + + num_threads = 12 + results = {} + errors = [] + barrier = threading.Barrier(num_threads) + + def stress_lazy_imports(idx): + try: + barrier.wait() + for _ in range(50): + _ = collections.OrderedDict + _ = functools.partial + _ = itertools.chain + _ = collections.defaultdict + _ = functools.lru_cache + _ = itertools.islice + results[idx] = ( + type(collections).__name__, + type(functools).__name__, + type(itertools).__name__, + ) + except Exception as e: + errors.append((idx, e)) + + threads = [ + threading.Thread(target=stress_lazy_imports, args=(i,)) + for i in range(num_threads) + ] + + for t in threads: + t.start() + for t in threads: + t.join() + + assert not errors, f"Errors: {errors}" + for idx, types_tuple in results.items(): + assert all(t == 'module' for t in types_tuple), f"Thread {idx}: {types_tuple}" + print("OK") + """) + + result = subprocess.run( + [sys.executable, "-c", code], + capture_output=True, + text=True + ) + self.assertEqual(result.returncode, 0, f"stdout: {result.stdout}, stderr: {result.stderr}") + self.assertIn("OK", result.stdout) + + +class LazyImportDisTests(unittest.TestCase): + def test_lazy_import_dis(self): + """dis should properly show lazy import""" + code = compile("lazy import foo", "exec", "exec") + f = io.StringIO() + dis.dis(code, file=f) + self.assertIn("foo + lazy", f.getvalue()) + + def test_normal_import_dis(self): + """non lazy imports should just show the name""" + code = compile("import foo", "exec", "exec") + f = io.StringIO() + dis.dis(code, file=f) + for line in f.getvalue().split('\n'): + if "IMPORT_NAME" in line: + self.assertIn("(foo)", line) + break + else: + self.assertFail("IMPORT_NAME not found") + + +@unittest.skipIf(_testcapi is None, 'need the _testcapi module') +class LazyCApiTests(unittest.TestCase): + def tearDown(self): + sys.set_lazy_imports("normal") + sys.set_lazy_imports_filter(None) + + def test_set_matches_sys(self): + self.assertEqual(_testcapi.PyImport_GetLazyImportsMode(), sys.get_lazy_imports()) + for mode in ("normal", "all", "none"): + _testcapi.PyImport_SetLazyImportsMode(mode) + self.assertEqual(_testcapi.PyImport_GetLazyImportsMode(), sys.get_lazy_imports()) + + def test_filter_matches_sys(self): + self.assertEqual(_testcapi.PyImport_GetLazyImportsFilter(), sys.get_lazy_imports_filter()) + + def filter(*args): + pass + + _testcapi.PyImport_SetLazyImportsFilter(filter) + self.assertEqual(_testcapi.PyImport_GetLazyImportsFilter(), sys.get_lazy_imports_filter()) + + def test_set_bad_filter(self): + self.assertRaises(ValueError, _testcapi.PyImport_SetLazyImportsFilter, 42) + + +if __name__ == '__main__': + unittest.main() diff --git a/Lib/test/test_pyrepl/test_utils.py b/Lib/test/test_pyrepl/test_utils.py index 656a1e441e0..3c55b6bdaee 100644 --- a/Lib/test/test_pyrepl/test_utils.py +++ b/Lib/test/test_pyrepl/test_utils.py @@ -89,10 +89,42 @@ def test_gen_colors_keyword_highlighting(self): ("obj.list", [(".", "op")]), ("obj.match", [(".", "op")]), ("b. \\\n format", [(".", "op")]), + ("lazy", []), + ("lazy()", [('(', 'op'), (')', 'op')]), # highlights ("set", [("set", "builtin")]), ("list", [("list", "builtin")]), (" \n dict", [("dict", "builtin")]), + ( + " lazy import", + [("lazy", "soft_keyword"), ("import", "keyword")], + ), + ( + "lazy from cool_people import pablo", + [ + ("lazy", "soft_keyword"), + ("from", "keyword"), + ("import", "keyword"), + ], + ), + ( + "if sad: lazy import happy", + [ + ("if", "keyword"), + (":", "op"), + ("lazy", "soft_keyword"), + ("import", "keyword"), + ], + ), + ( + "pass; lazy import z", + [ + ("pass", "keyword"), + (";", "op"), + ("lazy", "soft_keyword"), + ("import", "keyword"), + ], + ), ] for code, expected_highlights in cases: with self.subTest(code=code): diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py index 93f0b98de71..19427f2469e 100644 --- a/Lib/test/test_syntax.py +++ b/Lib/test/test_syntax.py @@ -3475,6 +3475,128 @@ def test_ifexp_body_stmt_else_stmt(self): ]: self._check_error(f"x = {lhs_stmt} if 1 else {rhs_stmt}", msg) + +class LazyImportRestrictionTestCase(SyntaxErrorTestCase): + """Test syntax restrictions for lazy imports.""" + + def test_lazy_import_in_try_block(self): + """Test that lazy imports are not allowed inside try blocks.""" + self._check_error("""\ +try: + lazy import os +except: + pass +""", "lazy import not allowed inside try/except blocks") + + self._check_error("""\ +try: + lazy from sys import path +except ImportError: + pass +""", "lazy from ... import not allowed inside try/except blocks") + + def test_lazy_import_in_trystar_block(self): + """Test that lazy imports are not allowed inside try* blocks.""" + self._check_error("""\ +try: + lazy import json +except* Exception: + pass +""", "lazy import not allowed inside try/except blocks") + + self._check_error("""\ +try: + lazy from collections import defaultdict +except* ImportError: + pass +""", "lazy from ... import not allowed inside try/except blocks") + + def test_lazy_import_in_except_block(self): + """Test that lazy imports are not allowed inside except blocks.""" + self._check_error("""\ +try: + sys.modules # trigger the except block +except* Exception: + lazy import sys +""", "lazy import not allowed inside try/except blocks") + + def test_lazy_import_in_function(self): + """Test that lazy imports are not allowed inside functions.""" + self._check_error("""\ +def func(): + lazy import math +""", "lazy import not allowed inside functions") + + self._check_error("""\ +def func(): + lazy from datetime import datetime +""", "lazy from ... import not allowed inside functions") + + def test_lazy_import_in_async_function(self): + """Test that lazy imports are not allowed inside async functions.""" + self._check_error("""\ +async def async_func(): + lazy import asyncio +""", "lazy import not allowed inside functions") + + self._check_error("""\ +async def async_func(): + lazy from json import loads +""", "lazy from ... import not allowed inside functions") + + def test_lazy_import_in_class(self): + """Test that lazy imports are not allowed inside classes.""" + self._check_error("""\ +class MyClass: + lazy import typing +""", "lazy import not allowed inside classes") + + self._check_error("""\ +class MyClass: + lazy from abc import ABC +""", "lazy from ... import not allowed inside classes") + + def test_lazy_import_star_forbidden(self): + """Test that 'lazy from ... import *' is forbidden everywhere.""" + # At module level should also be forbidden + self._check_error("lazy from os import *", + "lazy from ... import \\* is not allowed") + + # Inside function should give lazy function error first + self._check_error("""\ +def func(): + lazy from sys import * +""", "lazy from ... import not allowed inside functions") + + def test_lazy_import_nested_scopes(self): + """Test lazy imports in nested scopes.""" + self._check_error("""\ +class Outer: + def method(self): + lazy import sys +""", "lazy import not allowed inside functions") + + self._check_error("""\ +def outer(): + class Inner: + lazy import json +""", "lazy import not allowed inside classes") + + self._check_error("""\ +def outer(): + def inner(): + lazy from collections import deque +""", "lazy from ... import not allowed inside functions") + + def test_lazy_import_valid_cases(self): + """Test that lazy imports work at module level.""" + # These should compile without errors + compile("lazy import os", "", "exec") + compile("lazy from sys import path", "", "exec") + compile("lazy import json as j", "", "exec") + compile("lazy from datetime import datetime as dt", "", "exec") + + def load_tests(loader, tests, pattern): tests.addTest(doctest.DocTestSuite()) return tests diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py index b44e0c9779a..8974361c253 100644 --- a/Lib/test/test_sys.py +++ b/Lib/test/test_sys.py @@ -865,7 +865,8 @@ def test_sys_flags(self): "dont_write_bytecode", "no_user_site", "no_site", "ignore_environment", "verbose", "bytes_warning", "quiet", "hash_randomization", "isolated", "dev_mode", "utf8_mode", - "warn_default_encoding", "safe_path", "int_max_str_digits") + "warn_default_encoding", "safe_path", "int_max_str_digits", + "lazy_imports") for attr in attrs: self.assertHasAttr(sys.flags, attr) attr_type = bool if attr in ("dev_mode", "safe_path") else int diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py index a4a49fd44bb..eaca62b12d3 100644 --- a/Lib/test/test_traceback.py +++ b/Lib/test/test_traceback.py @@ -5319,5 +5319,47 @@ def expected(t, m, fn, l, f, E, e, z): ] self.assertEqual(actual, expected(**colors)) + +class TestLazyImportSuggestions(unittest.TestCase): + """Test that lazy imports are not reified when computing AttributeError suggestions.""" + + def test_attribute_error_does_not_reify_lazy_imports(self): + """Printing an AttributeError should not trigger lazy import reification.""" + # pkg.bar prints "BAR_MODULE_LOADED" when imported. + # If lazy import is reified during suggestion computation, we'll see it. + code = textwrap.dedent(""" + lazy import test.test_import.data.lazy_imports.pkg.bar + test.test_import.data.lazy_imports.pkg.nonexistent + """) + rc, stdout, stderr = assert_python_failure('-c', code) + self.assertNotIn(b"BAR_MODULE_LOADED", stdout) + + def test_traceback_formatting_does_not_reify_lazy_imports(self): + """Formatting a traceback should not trigger lazy import reification.""" + code = textwrap.dedent(""" + import traceback + lazy import test.test_import.data.lazy_imports.pkg.bar + try: + test.test_import.data.lazy_imports.pkg.nonexistent + except AttributeError: + traceback.format_exc() + print("OK") + """) + rc, stdout, stderr = assert_python_ok('-c', code) + self.assertIn(b"OK", stdout) + self.assertNotIn(b"BAR_MODULE_LOADED", stdout) + + def test_suggestion_still_works_for_non_lazy_attributes(self): + """Suggestions should still work for non-lazy module attributes.""" + code = textwrap.dedent(""" + lazy import test.test_import.data.lazy_imports.pkg.bar + # Typo for __name__ + test.test_import.data.lazy_imports.pkg.__nme__ + """) + rc, stdout, stderr = assert_python_failure('-c', code) + self.assertIn(b"__name__", stderr) + self.assertNotIn(b"BAR_MODULE_LOADED", stdout) + + if __name__ == "__main__": unittest.main() diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py index b0d2348c0e1..39d57c5f5b6 100644 --- a/Lib/test/test_types.py +++ b/Lib/test/test_types.py @@ -41,7 +41,7 @@ def clear_typing_caches(): class TypesTests(unittest.TestCase): def test_names(self): - c_only_names = {'CapsuleType'} + c_only_names = {'CapsuleType', 'LazyImportType'} ignored = {'new_class', 'resolve_bases', 'prepare_class', 'get_original_bases', 'DynamicClassAttribute', 'coroutine'} @@ -55,10 +55,11 @@ def test_names(self): 'CoroutineType', 'EllipsisType', 'FrameType', 'FunctionType', 'FrameLocalsProxyType', 'GeneratorType', 'GenericAlias', 'GetSetDescriptorType', - 'LambdaType', 'MappingProxyType', 'MemberDescriptorType', - 'MethodDescriptorType', 'MethodType', 'MethodWrapperType', - 'ModuleType', 'NoneType', 'NotImplementedType', 'SimpleNamespace', - 'TracebackType', 'UnionType', 'WrapperDescriptorType', + 'LambdaType', 'LazyImportType', 'MappingProxyType', + 'MemberDescriptorType', 'MethodDescriptorType', 'MethodType', + 'MethodWrapperType', 'ModuleType', 'NoneType', + 'NotImplementedType', 'SimpleNamespace', 'TracebackType', + 'UnionType', 'WrapperDescriptorType', } self.assertEqual(all_names, set(c_types.__all__)) self.assertEqual(all_names - c_only_names, set(py_types.__all__))