grimp 3.16__tar.gz → 3.18__tar.gz

{grimp-3.16 → grimp-3.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grimp
-Version: 3.16
+Version: 3.18
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License

{grimp-3.16 → grimp-3.18}/pyproject.toml

@@ -8,7 +8,7 @@ module-name = "grimp._rustgrimp"
 
 [project]
 name = "grimp"
-version = "3.16"
+version = "3.18"
 license = {text = "BSD 2-Clause License"}
 description = "Builds a queryable graph of the imports within one or more Python packages."
 authors = [

{grimp-3.16 → grimp-3.18}/rust/src/caching.rs

@@ -75,17 +75,27 @@ impl<'a, 'py> FromPyObject<'a, 'py> for ImportsByModule {
     }
 }
 
+/// The version of the data cache file format.
+///
+/// Bump this whenever the serialized structure changes. On read, a file with a
+/// different (or missing) version is treated as a version mismatch and rebuilt,
+/// rather than being mistaken for a corrupt file.
+const CACHE_SCHEMA_VERSION: u32 = 2;
+
 fn serialize_imports_by_module(
     imports_by_module: &HashMap<Module, HashSet<DirectImport>>,
 ) -> String {
-    let raw_map: HashMap<&str, Vec<(&str, usize, &str)>> = imports_by_module
+    // Fields are ordered to match the `get_import_details` dict (`imported`, `is_lazy`,
+    // `line_number`, `line_contents`); `importer` is the map key.
+    let raw_map: HashMap<&str, Vec<(&str, bool, usize, &str)>> = imports_by_module
         .iter()
         .map(|(module, imports)| {
-            let imports_vec: Vec<(&str, usize, &str)> = imports
+            let imports_vec: Vec<(&str, bool, usize, &str)> = imports
                 .iter()
                 .map(|import| {
                     (
                         import.imported.as_str(),
+                        import.is_lazy,
                         import.line_number,
                         import.line_contents.as_str(),
                     )
@@ -95,16 +105,33 @@ fn serialize_imports_by_module(
         })
         .collect();
 
-    serde_json::to_string(&raw_map).expect("Failed to serialize to JSON")
+    let envelope = serde_json::json!({
+        "version": CACHE_SCHEMA_VERSION,
+        "imports_by_module": raw_map,
+    });
+
+    serde_json::to_string(&envelope).expect("Failed to serialize to JSON")
 }
 
 pub fn parse_json_to_map(
     json_str: &str,
     filename: &str,
 ) -> GrimpResult<HashMap<Module, HashSet<DirectImport>>> {
-    let raw_map: HashMap<String, Vec<(String, usize, String)>> = serde_json::from_str(json_str)
+    // Parse into a generic value first, so we can distinguish genuinely corrupt
+    // JSON from a cache file written by a different format version (e.g. by an
+    // older Grimp). The latter should be silently rebuilt, not warned about.
+    let value: serde_json::Value = serde_json::from_str(json_str)
         .map_err(|_| GrimpError::CorruptCache(filename.to_string()))?;
 
+    let version = value.get("version").and_then(|v| v.as_u64());
+    if version != Some(CACHE_SCHEMA_VERSION as u64) {
+        return Err(GrimpError::CacheVersionMismatch(filename.to_string()));
+    }
+
+    let raw_map: HashMap<String, Vec<(String, bool, usize, String)>> =
+        serde_json::from_value(value.get("imports_by_module").cloned().unwrap_or_default())
+            .map_err(|_| GrimpError::CorruptCache(filename.to_string()))?;
+
     let mut parsed_map: HashMap<Module, HashSet<DirectImport>> = HashMap::new();
 
     for (module_name, imports) in raw_map {
@@ -113,12 +140,15 @@ pub fn parse_json_to_map(
         };
         let import_set: HashSet<DirectImport> = imports
             .into_iter()
-            .map(|(imported, line_number, line_contents)| DirectImport {
-                importer: module_name.clone(),
-                imported,
-                line_number,
-                line_contents,
-            })
+            .map(
+                |(imported, is_lazy, line_number, line_contents)| DirectImport {
+                    importer: module_name.clone(),
+                    imported,
+                    line_number,
+                    line_contents,
+                    is_lazy,
+                },
+            )
             .collect();
         parsed_map.insert(module, import_set);
     }

{grimp-3.16 → grimp-3.18}/rust/src/errors.rs

@@ -1,6 +1,6 @@
 use crate::exceptions;
 use pyo3::PyErr;
-use pyo3::exceptions::PyValueError;
+use pyo3::exceptions::{PyFileNotFoundError, PyUnicodeError, PyValueError};
 use ruff_python_parser::ParseError as RuffParseError;
 use thiserror::Error;
 
@@ -36,6 +36,15 @@ pub enum GrimpError {
 
     #[error("Could not use corrupt cache file {0}.")]
     CorruptCache(String),
+
+    #[error("Cache file {0} was written by a different version of Grimp.")]
+    CacheVersionMismatch(String),
+
+    #[error("{0}")]
+    FileNotFound(String),
+
+    #[error("{0}")]
+    UndecodableFile(String),
 }
 
 pub type GrimpResult<T> = Result<T, GrimpError>;
@@ -55,6 +64,12 @@ impl From<GrimpError> for PyErr {
                 line_number, text, ..
             } => PyErr::new::<exceptions::ParseError, _>((line_number, text)),
             GrimpError::CorruptCache(_) => exceptions::CorruptCache::new_err(value.to_string()),
+            GrimpError::CacheVersionMismatch(_) => {
+                exceptions::CacheVersionMismatch::new_err(value.to_string())
+            }
+            GrimpError::FileNotFound(_) => PyFileNotFoundError::new_err(value.to_string()),
+            // Not UnicodeDecodeError, as that can't be created from just a message.
+            GrimpError::UndecodableFile(_) => PyUnicodeError::new_err(value.to_string()),
         }
     }
 }

{grimp-3.16 → grimp-3.18}/rust/src/exceptions.rs

@@ -6,6 +6,7 @@ create_exception!(_rustgrimp, ModuleNotPresent, PyException);
 create_exception!(_rustgrimp, NoSuchContainer, PyException);
 create_exception!(_rustgrimp, InvalidModuleExpression, PyException);
 create_exception!(_rustgrimp, CorruptCache, PyException);
+create_exception!(_rustgrimp, CacheVersionMismatch, PyException);
 
 // We need to use here `pyclass(extends=PyException)` instead of `create_exception!`
 // since the exception contains custom data. See:

{grimp-3.16 → grimp-3.18}/rust/src/filesystem.rs

@@ -1,5 +1,6 @@
+use crate::errors::{GrimpError, GrimpResult};
 use itertools::Itertools;
-use pyo3::exceptions::{PyFileNotFoundError, PyTypeError, PyUnicodeDecodeError};
+use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
 use regex::Regex;
 use std::collections::HashMap;
@@ -14,6 +15,48 @@ use unindent::unindent;
 static ENCODING_RE: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r"^[ \t\f]*#.*?coding[:=][ \t]*([-_.a-zA-Z0-9]+)").unwrap());
 
+/// An encoding named in a Python source file's encoding declaration.
+enum Encoding {
+    /// True Latin-1 (ISO-8859-1): a straight byte-to-code-point mapping. This is handled
+    /// specially because encoding_rs follows the WHATWG standard, under which the `iso-8859-1`
+    /// label resolves to the Windows-1252 decoder instead (the two differ in the 0x80..=0x9f
+    /// range), and because Windows-1252 has undefined bytes that true Latin-1 decodes fine.
+    Latin1,
+    /// Any other encoding, delegated to encoding_rs.
+    Other(&'static encoding_rs::Encoding),
+}
+
+/// Look up the encoding named in a Python source file's encoding declaration.
+///
+/// encoding_rs only knows the WHATWG labels, but Python accepts other spellings too, such as
+/// `latin-1`, `utf_8`, `utf-8-sig` or `euc_jp`.
+fn lookup_encoding(name: &str) -> Option<Encoding> {
+    // Normalize the name like Python does: see `_get_normal_name` in Lib/tokenize.py, which
+    // special cases UTF-8 and Latin-1. Python's codec lookup also ignores the difference
+    // between underscores and hyphens.
+    //
+    // We check these special cases before deferring to encoding_rs, because some of the Latin-1
+    // aliases (e.g. `iso-8859-1`) are WHATWG labels that encoding_rs would otherwise resolve to
+    // the Windows-1252 decoder.
+    let normalized = name.to_ascii_lowercase().replace('_', "-");
+    let is_spelling_of = |canonical: &str| {
+        normalized == canonical || normalized.starts_with(&format!("{canonical}-"))
+    };
+    if ["latin-1", "iso-8859-1", "iso-latin-1"]
+        .into_iter()
+        .any(is_spelling_of)
+    {
+        return Some(Encoding::Latin1);
+    }
+    if is_spelling_of("utf-8") {
+        return encoding_rs::Encoding::for_label(b"utf-8").map(Encoding::Other);
+    }
+    // Try the name as given, then its normalized form.
+    encoding_rs::Encoding::for_label(name.as_bytes())
+        .or_else(|| encoding_rs::Encoding::for_label(normalized.as_bytes()))
+        .map(Encoding::Other)
+}
+
 pub trait FileSystem: Send + Sync {
     fn sep(&self) -> &str;
 
@@ -23,7 +66,7 @@ pub trait FileSystem: Send + Sync {
 
     fn exists(&self, file_name: &str) -> bool;
 
-    fn read(&self, file_name: &str) -> PyResult<String>;
+    fn read(&self, file_name: &str) -> GrimpResult<String>;
 
     fn write(&mut self, file_name: &str, contents: &str) -> PyResult<()>;
 }
@@ -83,7 +126,7 @@ impl FileSystem for RealBasicFileSystem {
         Path::new(file_name).is_file()
     }
 
-    fn read(&self, file_name: &str) -> PyResult<String> {
+    fn read(&self, file_name: &str) -> GrimpResult<String> {
         // Python files are assumed UTF-8 by default (PEP 686), but they can specify an alternative
         // encoding, which we need to take into account here.
         // See https://peps.python.org/pep-0263/
@@ -92,7 +135,7 @@ impl FileSystem for RealBasicFileSystem {
 
         let path = Path::new(file_name);
         let bytes = fs::read(path).map_err(|e| {
-            PyFileNotFoundError::new_err(format!("Failed to read file {file_name}: {e}"))
+            GrimpError::FileNotFound(format!("Failed to read file {file_name}: {e}"))
         })?;
 
         let s = String::from_utf8_lossy(&bytes);
@@ -110,24 +153,30 @@ impl FileSystem for RealBasicFileSystem {
         }
 
         if let Some(enc_name) = detected_encoding {
-            let encoding =
-                encoding_rs::Encoding::for_label(enc_name.as_bytes()).ok_or_else(|| {
-                    PyUnicodeDecodeError::new_err(format!(
-                        "Failed to decode file {file_name} (unknown encoding '{enc_name}')"
-                    ))
-                })?;
-            let (decoded_s, _, had_errors) = encoding.decode(&bytes);
-            if had_errors {
-                Err(PyUnicodeDecodeError::new_err(format!(
-                    "Failed to decode file {file_name} with encoding '{enc_name}'"
-                )))
-            } else {
-                Ok(decoded_s.into_owned())
+            let encoding = lookup_encoding(&enc_name).ok_or_else(|| {
+                GrimpError::UndecodableFile(format!(
+                    "Failed to decode file {file_name} (unknown encoding '{enc_name}')"
+                ))
+            })?;
+            match encoding {
+                // True Latin-1 maps every byte to the code point of the same value and so can
+                // never fail.
+                Encoding::Latin1 => Ok(bytes.iter().map(|&b| b as char).collect()),
+                Encoding::Other(encoding) => {
+                    let (decoded_s, _, had_errors) = encoding.decode(&bytes);
+                    if had_errors {
+                        Err(GrimpError::UndecodableFile(format!(
+                            "Failed to decode file {file_name} with encoding '{enc_name}'"
+                        )))
+                    } else {
+                        Ok(decoded_s.into_owned())
+                    }
+                }
             }
         } else {
             // Default to UTF-8 if no encoding is specified
             String::from_utf8(bytes).map_err(|e| {
-                PyUnicodeDecodeError::new_err(format!(
+                GrimpError::UndecodableFile(format!(
                     "Failed to decode file {file_name} as UTF-8: {e}"
                 ))
             })
@@ -173,7 +222,7 @@ impl PyRealBasicFileSystem {
     }
 
     fn read(&self, file_name: &str) -> PyResult<String> {
-        self.inner.read(file_name)
+        Ok(self.inner.read(file_name)?)
     }
 
     fn write(&mut self, file_name: &str, contents: &str) -> PyResult<()> {
@@ -253,11 +302,11 @@ impl FileSystem for FakeBasicFileSystem {
         self.contents.lock().unwrap().contains_key(file_name)
     }
 
-    fn read(&self, file_name: &str) -> PyResult<String> {
+    fn read(&self, file_name: &str) -> GrimpResult<String> {
         let contents = self.contents.lock().unwrap();
         match contents.get(file_name) {
             Some(file_contents) => Ok(file_contents.clone()),
-            None => Err(PyFileNotFoundError::new_err(format!(
+            None => Err(GrimpError::FileNotFound(format!(
                 "No such file: {file_name}"
             ))),
         }
@@ -301,7 +350,7 @@ impl PyFakeBasicFileSystem {
     }
 
     fn read(&self, file_name: &str) -> PyResult<String> {
-        self.inner.read(file_name)
+        Ok(self.inner.read(file_name)?)
     }
 
     fn write(&mut self, file_name: &str, contents: &str) -> PyResult<()> {

{grimp-3.16 → grimp-3.18}/rust/src/graph/graph_manipulation.rs

@@ -120,6 +120,7 @@ impl Graph {
         imported: ModuleToken,
         line_number: u32,
         line_contents: &str,
+        is_lazy: bool,
     ) {
         self.imports
             .entry(importer)
@@ -137,7 +138,7 @@ impl Graph {
             self.import_details
                 .entry((importer, imported))
                 .or_default()
-                .insert(PyImportDetails::new(line_number, line_contents));
+                .insert(PyImportDetails::new(line_number, line_contents, is_lazy));
         }
     }
 

{grimp-3.16 → grimp-3.18}/rust/src/graph/mod.rs

@@ -264,29 +264,45 @@ impl GraphWrapper {
         Ok(self.get_visible_module_by_name(module)?.is_squashed())
     }
 
-    #[pyo3(signature = (*, importer, imported, line_number=None, line_contents=None))]
+    #[pyo3(signature = (*, importer, imported, is_lazy=None, line_number=None, line_contents=None))]
     pub fn add_import(
         &mut self,
         importer: &str,
         imported: &str,
+        is_lazy: Option<bool>,
         line_number: Option<u32>,
         line_contents: Option<&str>,
-    ) {
-        let importer = self._graph.get_or_add_module(importer).token();
-        let imported = self._graph.get_or_add_module(imported).token();
-        match (line_number, line_contents) {
-            (Some(line_number), Some(line_contents)) => {
-                self._graph
-                    .add_detailed_import(importer, imported, line_number, line_contents)
-            }
-            (None, None) => {
+    ) -> PyResult<()> {
+        match (line_number, line_contents, is_lazy) {
+            (None, None, None) => {
+                let importer = self._graph.get_or_add_module(importer).token();
+                let imported = self._graph.get_or_add_module(imported).token();
                 self._graph.add_import(importer, imported);
             }
-            _ => {
-                // TODO handle better.
-                panic!("Expected line_number and line_contents, or neither.");
+            (Some(line_number), Some(line_contents), is_lazy) => {
+                let is_lazy = is_lazy.unwrap_or(false);
+                let importer = self._graph.get_or_add_module(importer).token();
+                let imported = self._graph.get_or_add_module(imported).token();
+                self._graph.add_detailed_import(
+                    importer,
+                    imported,
+                    line_number,
+                    line_contents,
+                    is_lazy,
+                );
+            }
+            (_, _, Some(_is_lazy)) => {
+                return Err(PyValueError::new_err(
+                    "You must provide line_number and line_contents when providing is_lazy.",
+                ));
+            }
+            (_, _, None) => {
+                return Err(PyValueError::new_err(
+                    "Expected line_number and line_contents, or neither.",
+                ));
             }
         }
+        Ok(())
     }
 
     #[pyo3(signature = (*, importer, imported))]
@@ -402,6 +418,7 @@ impl GraphWrapper {
                         imported.name(),
                         import_details.line_number(),
                         import_details.line_contents(),
+                        import_details.is_lazy(),
                     )
                 })
                 .sorted()
@@ -417,6 +434,7 @@ impl GraphWrapper {
                             "line_contents",
                             import_details.line_contents.into_py_any(py).unwrap(),
                         ),
+                        ("is_lazy", import_details.is_lazy.into_py_any(py).unwrap()),
                     ]
                     .into_py_dict(py)
                     .unwrap()
@@ -667,6 +685,7 @@ struct ImportDetails {
     imported: String,
     line_number: u32,
     line_contents: String,
+    is_lazy: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, new)]
@@ -754,6 +773,9 @@ pub struct PyImportDetails {
 
     #[getset(get_copy = "pub")]
     interned_line_contents: DefaultSymbol,
+
+    #[getset(get_copy = "pub")]
+    is_lazy: bool,
 }
 
 impl PyImportDetails {

{grimp-3.16 → grimp-3.18}/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,29 +117,24 @@ 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);
             }
-            Stmt::If(if_stmt) => match if_stmt.test.as_ref() {
-                Expr::Name(expr) => {
-                    if expr.id == "TYPE_CHECKING" {
-                        self.typechecking_only = true;
-                        walk_stmt(self, stmt);
-                        self.typechecking_only = false;
-                    } else {
-                        walk_stmt(self, stmt);
-                    }
+            Stmt::If(if_stmt) => {
+                // Only the branches guarded by `TYPE_CHECKING` are type checking only. The other
+                // branches (e.g. `else`) run when `TYPE_CHECKING` is false, that is, at runtime.
+                let outer_typechecking_only = self.typechecking_only;
+                self.typechecking_only = outer_typechecking_only || is_type_checking(&if_stmt.test);
+                self.visit_body(&if_stmt.body);
+                for clause in &if_stmt.elif_else_clauses {
+                    self.typechecking_only = outer_typechecking_only
+                        || clause.test.as_ref().is_some_and(is_type_checking);
+                    self.visit_elif_else_clause(clause);
                 }
-                Expr::Attribute(expr) if expr.attr.id == "TYPE_CHECKING" => {
-                    self.typechecking_only = true;
-                    walk_stmt(self, stmt);
-                    self.typechecking_only = false;
-                }
-                _ => {
-                    walk_stmt(self, stmt);
-                }
-            },
+                self.typechecking_only = outer_typechecking_only;
+            }
             _ => {
                 walk_stmt(self, stmt);
             }
@@ -143,6 +142,15 @@ impl<'a> StatementVisitor<'a> for Visitor<'a> {
     }
 }
 
+/// Whether the expression is `TYPE_CHECKING` or `<something>.TYPE_CHECKING`.
+fn is_type_checking(expr: &Expr) -> bool {
+    match expr {
+        Expr::Name(name) => name.id == "TYPE_CHECKING",
+        Expr::Attribute(attribute) => attribute.attr.id == "TYPE_CHECKING",
+        _ => false,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::parse_imports_from_code;

{grimp-3.16 → grimp-3.18}/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,
         })
     }
 }
@@ -127,7 +130,7 @@ fn scan_for_imports_no_py_single_module(
     let found_package_for_module = found_packages_by_module[module];
     let module_filename =
         _determine_module_filename(module, found_package_for_module, file_system).unwrap();
-    let module_contents = file_system.read(&module_filename).unwrap();
+    let module_contents = file_system.read(&module_filename)?;
     let imported_objects =
         import_parsing::parse_imports_from_code(&module_contents, &module_filename)?;
 
@@ -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,7 @@ 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();
     }

{grimp-3.16 → grimp-3.18}/rust/src/lib.rs

@@ -29,6 +29,7 @@ mod _rustgrimp {
 
     #[pymodule_export]
     use crate::exceptions::{
-        CorruptCache, InvalidModuleExpression, ModuleNotPresent, NoSuchContainer, ParseError,
+        CacheVersionMismatch, CorruptCache, InvalidModuleExpression, ModuleNotPresent,
+        NoSuchContainer, ParseError,
     };
 }

{grimp-3.16 → grimp-3.18}/src/grimp/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "3.16"
+__version__ = "3.18"
 
 from .application.graph import DetailedImport, Import, ImportGraph
 from .domain.analysis import PackageDependency, Route

{grimp-3.16 → grimp-3.18}/src/grimp/adaptors/caching.py

@@ -203,6 +203,12 @@ class Cache(AbstractCache):
         except rust.CorruptCache:
             logger.warning(f"Could not use corrupt cache file {data_cache_filename}.")
             return {}
+        except rust.CacheVersionMismatch:
+            logger.info(
+                f"Cache file {data_cache_filename} was written by a different version of Grimp; "
+                "rebuilding."
+            )
+            return {}
 
         logger.info(f"Used cache data file {data_cache_filename}.")
         return imports_by_module

{grimp-3.16 → grimp-3.18}/src/grimp/application/graph.py

@@ -27,6 +27,7 @@ ImportTuple = tuple[str, str]
 class DetailedImport(Import):
     line_number: int
     line_contents: str
+    is_lazy: bool
 
 
 class ImportGraph:
@@ -138,10 +139,15 @@ class ImportGraph:
         imported: str,
         line_number: int | None = None,
         line_contents: str | None = None,
+        is_lazy: bool | None = None,
     ) -> None:
         """
         Add a direct import between two modules to the graph. If the modules are not already
         present, they will be added to the graph.
+
+        Raises:
+            ValueError if only one of line_number and line_contents is supplied, or if
+            is_lazy is supplied without line_number and line_contents.
         """
         self._cached_modules = None
         self._rustgraph.add_import(
@@ -149,6 +155,7 @@ class ImportGraph:
             imported=imported,
             line_number=line_number,
             line_contents=line_contents,
+            is_lazy=is_lazy,
         )
 
     def remove_import(self, *, importer: str, imported: str) -> None:
@@ -249,6 +256,7 @@ class ImportGraph:
                 'imported': 'mypackage.imported',
                 'line_number': 5,
                 'line_contents': 'from mypackage import imported',
+                'is_lazy': False,
             },
             (additional imports here)
         ]

{grimp-3.16 → grimp-3.18}/src/grimp/application/usecases.py

@@ -184,6 +184,7 @@ def _assemble_graph(
                 imported=direct_import.imported.name,
                 line_number=direct_import.line_number,
                 line_contents=direct_import.line_contents,
+                is_lazy=direct_import.is_lazy,
             )
     return graph
 

{grimp-3.16 → grimp-3.18}/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)