grimp 3.17__tar.gz → 3.19__tar.gz

grimp-3.19/AUTHORS.rst

@@ -0,0 +1,16 @@
+
+Authors
+=======
+
+* David Seddon - https://seddonym.me
+* Kevin Amado - https://github.com/kamadorueda
+* Matthew Gamble - https://github.com/mwgamble
+* NetworkX developers - The shortest path algorithm was adapted from the NetworkX library https://networkx.org/.
+* Peter Byfield - https://github.com/Peter554
+* Shane Smiskol - https://github.com/sshane
+* Andreas Rammhold - https://github.com/andir
+* Nicholas Bunn - https://github.com/NicholasBunn
+* Nathan McDougall - https://github.com/nathanjmcdougall
+* Oleksandr Zaiats - https://github.com/z4y4ts
+* Nikhil Dabas - https://github.com/ndabas
+* Pierre-Yves Le Borgne - https://github.com/pylaterreur

grimp-3.19/LICENSE

@@ -0,0 +1,21 @@
+BSD 2-Clause License
+
+Copyright (c) 2018, David Seddon
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+  disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+  disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

{grimp-3.17 → grimp-3.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grimp
-Version: 3.17
+Version: 3.19
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
@@ -8,7 +8,6 @@ Classifier: Operating System :: Unix
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -22,7 +21,7 @@ License-File: AUTHORS.rst
 Summary: Builds a queryable graph of the imports within one or more Python packages.
 Author-email: David Seddon <david@seddonym.me>
 License: BSD 2-Clause License
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst; charset=UTF-8
 Project-URL: Documentation, https://grimp.readthedocs.io/
 Project-URL: Source-code, https://github.com/python-grimp/grimp/

{grimp-3.17 → grimp-3.19}/pyproject.toml

@@ -8,13 +8,13 @@ module-name = "grimp._rustgrimp"
 
 [project]
 name = "grimp"
-version = "3.17"
+version = "3.19"
 license = {text = "BSD 2-Clause License"}
 description = "Builds a queryable graph of the imports within one or more Python packages."
 authors = [
     {name = "David Seddon", email = "david@seddonym.me"},
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 dependencies = []
 classifiers = [
     "Development Status :: 5 - Production/Stable",
@@ -24,7 +24,6 @@ classifiers = [
     "Operating System :: POSIX",
     "Operating System :: Microsoft :: Windows",
     "Programming Language :: Python",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -60,6 +59,7 @@ dev = [
     "requests==2.32.3",
     "sqlalchemy==2.0.35",
     "google-cloud-audit-log==0.3.0",
+    "pyupgrade>=3.21.2",
 ]
 docs = [
     "sphinx>=7.4.7",

{grimp-3.17 → grimp-3.19}/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;
 
@@ -39,6 +39,12 @@ pub enum GrimpError {
 
     #[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>;
@@ -61,6 +67,9 @@ impl From<GrimpError> for PyErr {
             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.17 → grimp-3.19}/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.17 → grimp-3.19}/rust/src/graph/cycle_breakers.rs

@@ -1,6 +1,6 @@
-use crate::errors::GrimpResult;
+use crate::errors::{GrimpError, GrimpResult};
 
-use crate::graph::{Graph, ModuleToken};
+use crate::graph::{Graph, ModuleIterator, ModuleToken};
 use rustc_hash::{FxHashMap, FxHashSet};
 use slotmap::SecondaryMap;
 use std::cmp::Ordering;
@@ -9,17 +9,45 @@ impl Graph {
     pub fn nominate_cycle_breakers(
         &self,
         package: ModuleToken,
+        additional_packages: &[ModuleToken],
     ) -> GrimpResult<FxHashSet<(ModuleToken, ModuleToken)>> {
-        // Get children of this package.
-        let children = match self.module_children.get(package) {
-            Some(children) => children,
-            None => return Ok(FxHashSet::default()),
-        };
-        if children.len() < 2 {
+        if additional_packages.is_empty() {
+            // A single package was passed: the nodes of the graph are its children.
+            // Children of a single package can never overlap, so no need to check.
+            let children = match self.module_children.get(package) {
+                Some(children) => children.clone(),
+                None => return Ok(FxHashSet::default()),
+            };
+            self.nominate_cycle_breakers_for_nodes(&children)
+        } else {
+            // Multiple packages were passed: the packages themselves are the nodes.
+            let mut nodes: FxHashSet<ModuleToken> = FxHashSet::default();
+            nodes.insert(package);
+            nodes.extend(additional_packages.iter().copied());
+
+            // The packages must not overlap: if one is a descendant of another, the edges
+            // between them (as packages) would be ill-defined.
+            for node in &nodes {
+                for descendant in self.get_module_descendants(*node).tokens() {
+                    if nodes.contains(&descendant) {
+                        return Err(GrimpError::SharedDescendants);
+                    }
+                }
+            }
+
+            self.nominate_cycle_breakers_for_nodes(&nodes)
+        }
+    }
+
+    fn nominate_cycle_breakers_for_nodes(
+        &self,
+        nodes: &FxHashSet<ModuleToken>,
+    ) -> GrimpResult<FxHashSet<(ModuleToken, ModuleToken)>> {
+        if nodes.len() < 2 {
             return Ok(FxHashSet::default());
         }
         let (orig_imports, orig_reverse_imports, edge_weights) =
-            self.build_graph_maps_of_children(children);
+            self.build_graph_maps_of_nodes(nodes);
 
         // Make a copy of the graph. We'll iteratively remove nodes from this.
         let mut working_imports = orig_imports.clone();
@@ -166,9 +194,9 @@ impl Graph {
     // with empty sets if they have no imports to / from.
     // They are denormalized into two maps for fast lookups.
     #[allow(clippy::type_complexity)]
-    fn build_graph_maps_of_children(
+    fn build_graph_maps_of_nodes(
         &self,
-        children: &FxHashSet<ModuleToken>,
+        nodes: &FxHashSet<ModuleToken>,
     ) -> (
         SecondaryMap<ModuleToken, FxHashSet<ModuleToken>>, // Imports
         SecondaryMap<ModuleToken, FxHashSet<ModuleToken>>, // Reverse imports
@@ -180,25 +208,25 @@ impl Graph {
             SecondaryMap::default();
         let mut weights = FxHashMap::default();
 
-        for child in children {
-            orig_imports.insert(*child, FxHashSet::default());
-            orig_reverse_imports.insert(*child, FxHashSet::default());
+        for node in nodes {
+            orig_imports.insert(*node, FxHashSet::default());
+            orig_reverse_imports.insert(*node, FxHashSet::default());
         }
-        // Get number of imports between each child.
+        // Get number of imports between each node.
         // Add as edges.
-        for child_a in children {
-            for child_b in children.iter().filter(|child| *child != child_a) {
-                // Get number of imports from child_a to child_b (as package).
+        for node_a in nodes {
+            for node_b in nodes.iter().filter(|node| *node != node_a) {
+                // Get number of imports from node_a to node_b (as package).
                 let num_imports_from_a_to_b = self
-                    .find_direct_imports_between(*child_a, *child_b, true)
+                    .find_direct_imports_between(*node_a, *node_b, true)
                     .unwrap()
                     .len();
 
                 if num_imports_from_a_to_b > 0 {
                     // a depends on b - add it as an edge in our temporary graph.
-                    orig_imports[*child_a].insert(*child_b);
-                    orig_reverse_imports[*child_b].insert(*child_a);
-                    weights.insert((*child_a, *child_b), num_imports_from_a_to_b);
+                    orig_imports[*node_a].insert(*node_b);
+                    orig_reverse_imports[*node_b].insert(*node_a);
+                    weights.insert((*node_a, *node_b), num_imports_from_a_to_b);
                 }
             }
         }

{grimp-3.17 → grimp-3.19}/rust/src/graph/mod.rs

@@ -198,6 +198,33 @@ impl GraphWrapper {
 
         PyTuple::new(py, python_dependencies)
     }
+
+    fn convert_cycle_breakers_to_python<'py>(
+        &self,
+        py: Python<'py>,
+        cycle_breakers: FxHashSet<(ModuleToken, ModuleToken)>,
+    ) -> PyResult<Bound<'py, PySet>> {
+        PySet::new(
+            py,
+            cycle_breakers
+                .into_iter()
+                .map(|(importer, imported)| {
+                    let importer = self._graph.get_module(importer).unwrap();
+                    let imported = self._graph.get_module(imported).unwrap();
+                    Import::new(importer.name(), imported.name())
+                })
+                .map(|import| {
+                    PyTuple::new(
+                        py,
+                        [
+                            import.importer.into_py_any(py).unwrap(),
+                            import.imported.into_py_any(py).unwrap(),
+                        ],
+                    )
+                    .unwrap()
+                }),
+        )
+    }
 }
 
 /// Wrapper around the Graph struct that integrates with Python.
@@ -642,29 +669,17 @@ impl GraphWrapper {
         &self,
         py: Python<'py>,
         package: &str,
+        additional_packages: Vec<String>,
     ) -> PyResult<Bound<'py, PySet>> {
         let package = self.get_visible_module_by_name(package)?.token();
-        let cycle_breakers = self._graph.nominate_cycle_breakers(package)?;
-        PySet::new(
-            py,
-            cycle_breakers
-                .into_iter()
-                .map(|(importer, imported)| {
-                    let importer = self._graph.get_module(importer).unwrap();
-                    let imported = self._graph.get_module(imported).unwrap();
-                    Import::new(importer.name(), imported.name())
-                })
-                .map(|import| {
-                    PyTuple::new(
-                        py,
-                        [
-                            import.importer.into_py_any(py).unwrap(),
-                            import.imported.into_py_any(py).unwrap(),
-                        ],
-                    )
-                    .unwrap()
-                }),
-        )
+        let additional_packages = additional_packages
+            .iter()
+            .map(|package| Ok(self.get_visible_module_by_name(package)?.token()))
+            .collect::<PyResult<Vec<_>>>()?;
+        let cycle_breakers = self
+            ._graph
+            .nominate_cycle_breakers(package, &additional_packages)?;
+        self.convert_cycle_breakers_to_python(py, cycle_breakers)
     }
 
     #[pyo3(name = "clone")]

{grimp-3.17 → grimp-3.19}/rust/src/import_parsing.rs

@@ -122,25 +122,19 @@ impl<'a> StatementVisitor<'a> for Visitor<'a> {
                 }
                 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);
             }
@@ -148,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.17 → grimp-3.19}/rust/src/import_scanning.rs

@@ -130,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)?;
 

{grimp-3.17 → grimp-3.19}/src/grimp/__init__.py

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

{grimp-3.17 → grimp-3.19}/src/grimp/application/graph.py

@@ -476,14 +476,18 @@ class ImportGraph:
 
         return _dependencies_from_tuple(result)
 
-    def nominate_cycle_breakers(self, package: str) -> set[ImportTuple]:
+    def nominate_cycle_breakers(self, package: str, *additional_packages: str) -> set[ImportTuple]:
         """
-        Identify a set of imports that, if removed, would make the package locally acyclic.
+        Identify a set of imports that, if removed, would make the supplied packages acyclic.
+
+        For more information see the docs in usage.rst.
         """
-        if not self._rustgraph.contains_module(package):
-            msg = f'"{package}" not present in the graph.'
-            raise ModuleNotPresent(msg)
-        return self._rustgraph.nominate_cycle_breakers(package)
+        for package_ in (package, *additional_packages):
+            if not self._rustgraph.contains_module(package_):
+                msg = f'"{package_}" not present in the graph.'
+                raise ModuleNotPresent(msg)
+
+        return self._rustgraph.nominate_cycle_breakers(package, additional_packages)
 
     # Dunder methods
     # --------------

{grimp-3.17 → grimp-3.19}/src/grimp/application/ports/timing.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import abc
 from types import TracebackType
+from typing import Self
 
 
 class Timer(abc.ABC):
@@ -22,7 +23,7 @@ class Timer(abc.ABC):
         # We use a stack so context managers can be nested.
         self._start_stack: list[float] = []
 
-    def __enter__(self) -> Timer:
+    def __enter__(self) -> Self:
         self._start_stack.append(self.get_current_time())
         return self