Populate is_lazy in DirectImport

Author: seddonym

rust/src/caching.rs

@@ -118,6 +118,7 @@ pub fn parse_json_to_map(
                 imported,
                 line_number,
                 line_contents,
+                is_lazy: false,  // TODO get working with cache.
             })
             .collect();
         parsed_map.insert(module, import_set);

rust/src/import_parsing.rs

@@ -10,6 +10,7 @@ pub struct ImportedObject {
     pub line_number: usize,
     pub line_contents: String,
     pub typechecking_only: bool,
+    pub is_lazy: bool,
 }
 
 impl ImportedObject {
@@ -18,12 +19,14 @@ impl ImportedObject {
         line_number: usize,
         line_contents: String,
         typechecking_only: bool,
+        is_lazy: bool,
     ) -> Self {
         Self {
             name,
             line_number,
             line_contents,
             typechecking_only,
+            is_lazy,
         }
     }
 }
@@ -84,6 +87,7 @@ impl<'a> StatementVisitor<'a> for Visitor<'a> {
                         line_number.get(),
                         self.source_code.line_text(line_number).trim().to_string(),
                         self.typechecking_only,
+                        import_stmt.is_lazy,
                     ))
                 }
                 walk_stmt(self, stmt);
@@ -113,6 +117,7 @@ impl<'a> StatementVisitor<'a> for Visitor<'a> {
                         line_number.get(),
                         self.source_code.line_text(line_number).trim().to_string(),
                         self.typechecking_only,
+                        import_from_stmt.is_lazy,
                     ))
                 }
                 walk_stmt(self, stmt);

rust/src/import_scanning.rs

@@ -16,6 +16,7 @@ pub struct DirectImport {
     pub imported: String,
     pub line_number: usize,
     pub line_contents: String,
+    pub is_lazy: bool,
 }
 
 impl<'a, 'py> FromPyObject<'a, 'py> for DirectImport {
@@ -26,12 +27,14 @@ impl<'a, 'py> FromPyObject<'a, 'py> for DirectImport {
         let imported: String = ob.getattr("imported")?.getattr("name")?.extract()?;
         let line_number: usize = ob.getattr("line_number")?.extract()?;
         let line_contents: String = ob.getattr("line_contents")?.extract()?;
+        let is_lazy: bool = ob.getattr("is_lazy")?.extract()?;
 
         Ok(DirectImport {
             importer,
             imported,
             line_number,
             line_contents,
+            is_lazy,
         })
     }
 }
@@ -152,6 +155,7 @@ fn scan_for_imports_no_py_single_module(
                     imported: imported_module.name.to_string(),
                     line_number: imported_object.line_number,
                     line_contents: imported_object.line_contents,
+                    is_lazy: imported_object.is_lazy,
                 });
             }
             None => {
@@ -165,6 +169,7 @@ fn scan_for_imports_no_py_single_module(
                         imported: imported_module,
                         line_number: imported_object.line_number,
                         line_contents: imported_object.line_contents,
+                        is_lazy: imported_object.is_lazy,
                     });
                 }
             }
@@ -196,6 +201,9 @@ fn to_py_direct_imports<'a>(
         kwargs
             .set_item("line_contents", &rust_import.line_contents)
             .unwrap();
+        kwargs
+            .set_item("is_lazy", &rust_import.is_lazy)
+            .unwrap();
         let py_direct_import = py_direct_import_class.call((), Some(&kwargs)).unwrap();
         pyset.add(&py_direct_import).unwrap();
     }

src/grimp/domain/valueobjects.py

@@ -55,9 +55,12 @@ class DirectImport:
     imported: Module
     line_number: int
     line_contents: str
+    # Import in the form `lazy import` or `lazy from import`.
+    is_lazy: bool = False
 
     def __str__(self) -> str:
-        return f"{self.importer} -> {self.imported} (l. {self.line_number})"
+        lazy_label = ", lazy" if self.is_lazy else ""
+        return f"{self.importer} -> {self.imported} (l. {self.line_number}{lazy_label})"
 
 
 @dataclass(frozen=True, order=True)

tests/unit/application/test_scanning.py

@@ -152,66 +152,77 @@ def test_lazy_imports():
                 imported=Module("foo.two"),
                 line_number=2,
                 line_contents="lazy import foo.two",
+                is_lazy=True,
             ),
             DirectImport(
                 importer=Module("foo.one.blue"),
                 imported=Module("externalone"),
                 line_number=3,
                 line_contents="lazy import externalone",
+                is_lazy=True,
             ),
             DirectImport(
                 importer=Module("foo.one.blue"),
                 imported=Module("externaltwo"),
                 line_number=4,
                 line_contents="lazy import externaltwo.subpackage  # with comment afterwards.",
+                is_lazy=True,
             ),
             DirectImport(
                 importer=Module("foo.one.blue"),
                 imported=Module("foo.one.green"),
                 line_number=8,
                 line_contents="lazy from foo.one import green",
+                is_lazy=True,
             ),
             DirectImport(
                 importer=Module("foo.one.blue"),
                 imported=Module("foo.two.yellow"),
                 line_number=9,
                 line_contents="lazy from foo.two import yellow",
+                is_lazy=True,
             ),
             DirectImport(
                 importer=Module("foo.one.blue"),
                 imported=Module("foo.three"),
                 line_number=11,
                 line_contents="lazy from foo import three",
+                is_lazy=True,
             ),
             DirectImport(
                 importer=Module("foo.one.blue"),
                 imported=Module("external"),
                 line_number=12,
                 line_contents="lazy from external import one",
+                is_lazy=True,
             ),
             DirectImport(
                 importer=Module("foo.one.blue"),
                 imported=Module("external"),
                 line_number=13,
                 line_contents="lazy from external.two import blue  # with comment afterwards.",
+                is_lazy=True,
             ),
             DirectImport(
                 importer=Module("foo.one.blue"),
                 imported=Module("foo.one.green"),
                 line_number=16,
                 line_contents="lazy from . import green",
+                is_lazy=True,
             ),
             DirectImport(
                 importer=Module("foo.one.blue"),
                 imported=Module("foo.two.yellow"),
                 line_number=17,
                 line_contents="lazy from ..two import yellow",
+                is_lazy=True,
             ),
             DirectImport(
                 importer=Module("foo.one.blue"),
                 imported=Module("foo.three"),
                 line_number=18,
                 line_contents="lazy from .. import three",
+                is_lazy=True,
             ),
         }
     }

tests/unit/domain/test_valueobjects.py

@@ -33,6 +33,15 @@ def test_str(self):
             line_contents="import bar",
         )
         assert str(import_path) == "foo -> bar (l. 10)"
+    def test_lazy_str(self):
+        import_path = DirectImport(
+            importer=Module("foo"),
+            imported=Module("bar"),
+            line_number=10,
+            line_contents="import bar",
+            is_lazy=True,
+        )
+        assert str(import_path) == "foo -> bar (l. 10, lazy)"
 
 
 class TestLayer: