Add test coverage for lazy imports

Author: seddonym

CHANGELOG.rst

@@ -7,7 +7,8 @@ latest
 
 * Fix panic error when scanning imports of nonexistent namespace children
   (https://github.com/python-grimp/grimp/issues/308).
-* Officially support freethreaded Python 3.14.
+* Officially support freethreaded Python 3.14+.
+* Officially support Python 3.15, including lazy imports.
 
 3.15 (2026-07-03)
 -----------------

tests/assets/lazyimports/__init__.py

@@ -0,0 +1,5 @@
+lazy import lazyimports.two.blue
+lazy from lazyimports import two
+if TYPE_CHECKING:
+    lazy import lazyimports.two.green
+    lazy from lazyimports.three import SOME_CONSTANT

tests/assets/lazyimports/one.py

@@ -0,0 +1 @@
+SOME_CONSTANT = "some-constant"

tests/assets/lazyimports/three.py

@@ -0,0 +1,20 @@
+import grimp
+
+
+def test_build_graph_with_lazy_imports():
+    """
+    Tests we can cope with lazy imports (Python 3.15+).
+
+    Under the hood we use ruff's parser, which understands lazy imports even
+    when this is running under a different Python version.
+    """
+    graph = grimp.build_graph("lazyimports", cache_dir=None)
+
+    result = graph.find_modules_directly_imported_by("lazyimports.one")
+
+    assert {
+        "lazyimports.three",
+        "lazyimports.two",
+        "lazyimports.two.blue",
+        "lazyimports.two.green",
+    } == result

tests/assets/lazyimports/two/__init__.py

@@ -81,6 +81,143 @@ def test_absolute_imports(include_external_packages, expected_result):
     assert {module_file_to_scan: expected_result} == result
 
 
+def test_lazy_imports():
+    module_file_to_scan = _module_to_module_file(Module("foo.one.blue"))
+    all_modules = {
+        Module("foo"),
+        Module("foo.one"),
+        Module("foo.one.blue"),
+        Module("foo.one.green"),
+        Module("foo.two"),
+        Module("foo.two.brown"),
+        Module("foo.two.yellow"),
+        Module("foo.three"),
+    }
+    file_system = rust.FakeBasicFileSystem(
+        contents="""
+            /path/to/foo/
+                __init__.py
+                one/
+                    __init__.py
+                    blue.py
+                    green.py
+                two/
+                    __init__.py
+                    brown.py
+                    yellow.py
+                three.py
+        """,
+        content_map={
+            "/path/to/foo/one/blue.py": """
+                # Absolute no-from
+                lazy import foo.two
+                lazy import externalone
+                lazy import externaltwo.subpackage  # with comment afterwards.
+                arbitrary_expression = 1
+                
+                # Absolute from
+                lazy from foo.one import green
+                lazy from foo.two import yellow
+                if t.TYPE_CHECKING:
+                    lazy from foo import three
+                lazy from external import one
+                lazy from external.two import blue  # with comment afterwards.
+                
+                # Relative from
+                lazy from . import green
+                lazy from ..two import yellow
+                lazy from .. import three
+            """
+        }
+    )
+
+    with override_settings(FILE_SYSTEM=file_system):
+        result = scanning.scan_imports(
+            {module_file_to_scan},
+            found_packages={
+                FoundPackage(
+                    name="foo",
+                    directory="/path/to/foo",
+                    module_files=_modules_to_module_files(all_modules),
+                )
+            },
+            include_external_packages=True,
+            exclude_type_checking_imports=False,
+        )
+
+    expected = {
+        module_file_to_scan: {
+            DirectImport(
+                importer=Module("foo.one.blue"),
+                imported=Module("foo.two"),
+                line_number=2,
+                line_contents="lazy import foo.two",
+            ),
+            DirectImport(
+                importer=Module("foo.one.blue"),
+                imported=Module("externalone"),
+                line_number=3,
+                line_contents="lazy import externalone",
+            ),
+            DirectImport(
+                importer=Module("foo.one.blue"),
+                imported=Module("externaltwo"),
+                line_number=4,
+                line_contents="lazy import externaltwo.subpackage  # with comment afterwards.",
+            ),
+            DirectImport(
+                importer=Module("foo.one.blue"),
+                imported=Module("foo.one.green"),
+                line_number=8,
+                line_contents="lazy from foo.one import green",
+            ),
+            DirectImport(
+                importer=Module("foo.one.blue"),
+                imported=Module("foo.two.yellow"),
+                line_number=9,
+                line_contents="lazy from foo.two import yellow",
+            ),
+            DirectImport(
+                importer=Module("foo.one.blue"),
+                imported=Module("foo.three"),
+                line_number=11,
+                line_contents="lazy from foo import three",
+            ),
+            DirectImport(
+                importer=Module("foo.one.blue"),
+                imported=Module("external"),
+                line_number=12,
+                line_contents="lazy from external import one",
+            ),
+            DirectImport(
+                importer=Module("foo.one.blue"),
+                imported=Module("external"),
+                line_number=13,
+                line_contents="lazy from external.two import blue  # with comment afterwards.",
+            ),
+            DirectImport(
+                importer=Module("foo.one.blue"),
+                imported=Module("foo.one.green"),
+                line_number=16,
+                line_contents="lazy from . import green",
+            ),
+            DirectImport(
+                importer=Module("foo.one.blue"),
+                imported=Module("foo.two.yellow"),
+                line_number=17,
+                line_contents="lazy from ..two import yellow",
+            ),
+            DirectImport(
+                importer=Module("foo.one.blue"),
+                imported=Module("foo.three"),
+                line_number=18,
+                line_contents="lazy from .. import three",
+            ),
+        }
+    }
+    assert result == expected
+
+
 def test_non_ascii():
     blue_module = Module("mypackage.blue")
     blue_module_file = _module_to_module_file(blue_module)