grimp 3.1__tar.gz → 3.2__tar.gz

{grimp-3.1 → grimp-3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: grimp
-Version: 3.1
+Version: 3.2
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Utilities

{grimp-3.1 → grimp-3.2}/pyproject.toml

@@ -8,7 +8,7 @@ module-name = "grimp._rustgrimp"
 
 [project]
 name = "grimp"
-version = "3.1"
+version = "3.2"
 license = {text = "BSD 2-Clause License"}
 description = "Builds a queryable graph of the imports within one or more Python packages."
 authors = [
@@ -30,6 +30,7 @@ classifiers = [
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Rust",
     "Topic :: Utilities",

{grimp-3.1 → grimp-3.2}/rust/src/layers.rs

@@ -6,10 +6,10 @@ use std::collections::HashSet;
 use std::time::Instant;
 
 /// A group of layers at the same level in the layering.
-/// These layers should be independent.
 #[derive(PartialEq, Eq, Hash, Debug)]
 pub struct Level<'a> {
     pub layers: Vec<&'a str>,
+    pub independent: bool,
 }
 
 pub fn find_illegal_dependencies<'a>(
@@ -45,6 +45,8 @@ pub fn find_illegal_dependencies<'a>(
     dependencies
 }
 
+/// Return every permutation of modules that exist in the graph
+/// in which the second should not import the first.
 fn _generate_module_permutations<'a>(
     graph: &'a ImportGraph,
     levels: &'a [Level],
@@ -69,13 +71,18 @@ fn _generate_module_permutations<'a>(
                     continue;
                 }
 
-                // Build the layers that mustn't import this higher layer. That
-                // includes lower layers and siblings.
+                // Build the layers that mustn't import this higher layer. 
+                // That includes:
+                // * lower layers.
+                // * sibling layers, if the layer is independent.
                 let mut layers_forbidden_to_import_higher_layer: Vec<&str> = vec![];
-                for potential_sibling_layer in &higher_level.layers {
-                    if potential_sibling_layer != higher_layer {
-                        // It's a sibling layer.
-                        layers_forbidden_to_import_higher_layer.push(potential_sibling_layer);
+
+                if higher_level.independent {
+                    for potential_sibling_layer in &higher_level.layers {
+                        if potential_sibling_layer != higher_layer {
+                            // It's a sibling layer.
+                            layers_forbidden_to_import_higher_layer.push(potential_sibling_layer);
+                        }
                     }
                 }
 
@@ -333,12 +340,15 @@ mod tests {
         ]));
         let levels = vec![
             Level {
+                independent: true,
                 layers: vec!["high"],
             },
             Level {
+                independent: true,
                 layers: vec!["mid_a", "mid_b", "mid_c"],
             },
             Level {
+                independent: true,
                 layers: vec!["low"],
             },
         ];
@@ -405,9 +415,11 @@ mod tests {
         ]));
         let levels = vec![
             Level {
+                independent: true,
                 layers: vec!["high"],
             },
             Level {
+                independent: true,
                 layers: vec!["low"],
             },
         ];
@@ -460,12 +472,15 @@ mod tests {
         ]));
         let levels = vec![
             Level {
+                independent: true,
                 layers: vec!["high"],
             },
             Level {
+                independent: true,
                 layers: vec!["mid_a", "mid_b", "mid_c"],
             },
             Level {
+                independent: true,
                 layers: vec!["low"],
             },
         ];
@@ -553,16 +568,109 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_generate_module_permutations_sibling_layer_not_independent() {
+        let graph = ImportGraph::new(HashMap::from([
+            ("mypackage.low", HashSet::new()),
+            ("mypackage.low.blue", HashSet::from(["mypackage.utils"])),
+            ("mypackage.low.green", HashSet::new()),
+            (
+                "mypackage.low.green.alpha",
+                HashSet::from(["mypackage.high.yellow"]),
+            ),
+            ("mypackage.mid_a", HashSet::new()),
+            ("mypackage.mid_a.foo", HashSet::new()),
+            ("mypackage.mid_b", HashSet::new()),
+            ("mypackage.mid_b.foo", HashSet::new()),
+            ("mypackage.mid_c", HashSet::new()),
+            ("mypackage.mid_c.foo", HashSet::new()),
+            ("mypackage.high", HashSet::from(["mypackage.low.blue"])),
+            ("mypackage.high.yellow", HashSet::new()),
+            ("mypackage.high.red", HashSet::new()),
+            ("mypackage.high.red.beta", HashSet::new()),
+            ("mypackage.utils", HashSet::from(["mypackage.high.red"])),
+        ]));
+        let levels = vec![
+            Level {
+                independent: true,
+                layers: vec!["high"],
+            },
+            Level {
+                independent: false,
+                layers: vec!["mid_a", "mid_b", "mid_c"],
+            },
+            Level {
+                independent: true,
+                layers: vec!["low"],
+            },
+        ];
+        let containers = HashSet::from(["mypackage"]);
+
+        let perms = _generate_module_permutations(&graph, &levels, &containers);
+
+        let result: HashSet<(String, String, Option<String>)> = HashSet::from_iter(perms);
+        let (high, mid_a, mid_b, mid_c, low) = (
+            "mypackage.high",
+            "mypackage.mid_a",
+            "mypackage.mid_b",
+            "mypackage.mid_c",
+            "mypackage.low",
+        );
+        assert_eq!(
+            result,
+            HashSet::from_iter([
+                (
+                    high.to_string(),
+                    mid_a.to_string(),
+                    Some("mypackage".to_string())
+                ),
+                (
+                    high.to_string(),
+                    mid_b.to_string(),
+                    Some("mypackage".to_string())
+                ),
+                (
+                    high.to_string(),
+                    mid_c.to_string(),
+                    Some("mypackage".to_string())
+                ),
+                (
+                    high.to_string(),
+                    low.to_string(),
+                    Some("mypackage".to_string())
+                ),
+                (
+                    mid_a.to_string(),
+                    low.to_string(),
+                    Some("mypackage".to_string())
+                ),
+                (
+                    mid_b.to_string(),
+                    low.to_string(),
+                    Some("mypackage".to_string())
+                ),
+                (
+                    mid_c.to_string(),
+                    low.to_string(),
+                    Some("mypackage".to_string())
+                ),
+            ])
+        );
+    }
+
     #[test]
     fn test_layers_from_levels() {
         let levels = vec![
             Level {
+                independent: true,
                 layers: vec!["high"],
             },
             Level {
+                independent: true,
                 layers: vec!["medium_a", "medium_b", "medium_c"],
             },
             Level {
+                independent: true,
                 layers: vec!["low"],
             },
         ];

{grimp-3.1 → grimp-3.2}/rust/src/lib.rs

@@ -50,8 +50,11 @@ pub fn find_illegal_dependencies<'a>(
 fn rustify_levels(levels_python: &PyTuple) -> Vec<Level> {
     let mut rust_levels: Vec<Level> = vec![];
     for level_python in levels_python.into_iter() {
-        let layers: HashSet<&str> = level_python.extract().unwrap();
+        let level_dict = level_python.downcast::<PyDict>().unwrap();
+        let layers: HashSet<&str> = level_dict.get_item("layers").unwrap().extract().unwrap();
+        let independent: bool = level_dict.get_item("independent").unwrap().extract().unwrap();
         rust_levels.push(Level {
+            independent,
             layers: layers.into_iter().collect(),
         });
     }
@@ -104,16 +107,38 @@ fn convert_dependencies_to_python<'a>(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use pyo3::types::{PySet, PyTuple};
+
+    // Macro to easily define a python dict.
+    // Adapted from the hash_map! macro in https://github.com/jofas/map_macro.
+    macro_rules! pydict {
+        ($py: ident, {$($k: expr => $v: expr),*, $(,)?}) => {
+            {
+                let dict = PyDict::new($py);
+                $(
+                    dict.set_item($k, $v)?;
+                )*
+                dict
+            }
+        };
+    }
 
     #[test]
     fn test_rustify_levels_no_sibling_layers() {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| -> PyResult<()> {
-            let elements: Vec<&PySet> = vec![
-                PySet::new(py, &vec!["high"]).unwrap(),
-                PySet::new(py, &vec!["medium"]).unwrap(),
-                PySet::new(py, &vec!["low"]).unwrap(),
+            let elements: Vec<&PyDict> = vec![
+                pydict! (py, {
+                    "independent" => true,
+                    "layers" => HashSet::from(["high"]),
+                }),
+                pydict! (py, {
+                    "independent" => true,
+                    "layers" => HashSet::from(["medium"]),
+                }),
+                pydict! (py, {
+                    "independent" => true,
+                    "layers" => HashSet::from(["low"]),
+                })
             ];
             let python_levels: &PyTuple = PyTuple::new(py, elements);
 
@@ -123,12 +148,15 @@ mod tests {
                 result,
                 vec![
                     Level {
+                        independent: true,
                         layers: vec!["high"]
                     },
                     Level {
+                        independent: true,
                         layers: vec!["medium"]
                     },
                     Level {
+                        independent: true,
                         layers: vec!["low"]
                     }
                 ]
@@ -143,10 +171,23 @@ mod tests {
     fn test_rustify_levels_sibling_layers() {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| -> PyResult<()> {
-            let elements: Vec<&PySet> = vec![
-                PySet::new(py, &vec!["high"]).unwrap(),
-                PySet::new(py, &vec!["blue", "green", "orange"]).unwrap(),
-                PySet::new(py, &vec!["low"]).unwrap(),
+            let elements: Vec<&PyDict> = vec![
+                pydict! (py, {
+                    "independent" => true,
+                    "layers" => HashSet::from(["high"]),
+                }),
+                pydict! (py, {
+                    "independent" => true,
+                    "layers" => HashSet::from(["blue", "green", "orange"]),
+                }),
+                pydict! (py, {
+                    "independent" => false,
+                    "layers" => HashSet::from(["red", "yellow"]),
+                }),
+                pydict! (py, {
+                    "independent" => true,
+                    "layers" => HashSet::from(["low"]),
+                })
             ];
             let python_levels: &PyTuple = PyTuple::new(py, elements);
 
@@ -159,12 +200,19 @@ mod tests {
                 result,
                 vec![
                     Level {
+                        independent: true,
                         layers: vec!["high"]
                     },
                     Level {
+                        independent: true,
                         layers: vec!["blue", "green", "orange"]
                     },
                     Level {
+                        independent: false,
+                        layers: vec!["red", "yellow"]
+                    },
+                    Level {
+                        independent: true,
                         layers: vec!["low"]
                     }
                 ]

{grimp-3.1 → grimp-3.2}/rust/tests/large.rs

@@ -21,18 +21,23 @@ fn test_large_graph() {
 
     let levels = vec![
         Level {
+            independent: true,
             layers: vec!["plugins"],
         },
         Level {
+            independent: true,
             layers: vec!["interfaces"],
         },
         Level {
+            independent: true,
             layers: vec!["application"],
         },
         Level {
+            independent: true,
             layers: vec!["domain"],
         },
         Level {
+            independent: true,
             layers: vec!["data"],
         },
     ];

{grimp-3.1 → grimp-3.2}/src/grimp/__init__.py

@@ -1,8 +1,8 @@
-__version__ = "3.1"
+__version__ = "3.2"
 
 from .application.ports.graph import DetailedImport, ImportGraph
 from .domain.analysis import PackageDependency, Route
-from .domain.valueobjects import DirectImport, Module
+from .domain.valueobjects import DirectImport, Module, Layer
 from .main import build_graph
 
 __all__ = [
@@ -13,4 +13,5 @@ __all__ = [
     "PackageDependency",
     "Route",
     "build_graph",
+    "Layer",
 ]

grimp-3.2/src/grimp/adaptors/_layers.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Iterator, Sequence, TypedDict
+
+from grimp import Route
+from grimp import _rustgrimp as rust  # type: ignore[attr-defined]
+
+if TYPE_CHECKING:
+    from grimp.adaptors.graph import ImportGraph
+
+from grimp.domain.analysis import PackageDependency
+from grimp.exceptions import NoSuchContainer
+from grimp.domain.valueobjects import Layer
+
+
+def parse_layers(layers: Sequence[Layer | str | set[str]]) -> tuple[Layer, ...]:
+    """
+    Convert the passed raw `layers` into `Layer`s.
+    """
+    out_layers = []
+    for layer in layers:
+        if isinstance(layer, Layer):
+            out_layers.append(layer)
+        elif isinstance(layer, str):
+            out_layers.append(Layer(layer, independent=True))
+        else:
+            out_layers.append(Layer(*tuple(layer), independent=True))
+    return tuple(out_layers)
+
+
+def find_illegal_dependencies(
+    graph: ImportGraph,
+    layers: Sequence[Layer],
+    containers: set[str],
+) -> set[PackageDependency]:
+    """
+    Find dependencies that don't conform to the supplied layered architecture.
+
+    See ImportGraph.find_illegal_dependencies_for_layers.
+
+    The only difference between this and the method is that the containers passed in
+    is already a (potentially empty) set.
+    """
+    try:
+        rust_package_dependency_tuple = rust.find_illegal_dependencies(
+            levels=tuple(
+                {"layers": layer.module_tails, "independent": layer.independent}
+                for layer in layers
+            ),
+            containers=set(containers),
+            importeds_by_importer=graph._importeds_by_importer,
+        )
+    except rust.NoSuchContainer as e:
+        raise NoSuchContainer(str(e))
+
+    rust_package_dependencies = _dependencies_from_tuple(rust_package_dependency_tuple)
+    return rust_package_dependencies
+
+
+class _RustRoute(TypedDict):
+    heads: frozenset[str]
+    middle: tuple[str, ...]
+    tails: frozenset[str]
+
+
+class _RustPackageDependency(TypedDict):
+    importer: str
+    imported: str
+    routes: tuple[_RustRoute, ...]
+
+
+def _dependencies_from_tuple(
+    rust_package_dependency_tuple: tuple[_RustPackageDependency, ...]
+) -> set[PackageDependency]:
+    return {
+        PackageDependency(
+            imported=dep_dict["imported"],
+            importer=dep_dict["importer"],
+            routes=frozenset(
+                {
+                    Route(
+                        heads=route_dict["heads"],
+                        middle=route_dict["middle"],
+                        tails=route_dict["tails"],
+                    )
+                    for route_dict in dep_dict["routes"]
+                }
+            ),
+        )
+        for dep_dict in rust_package_dependency_tuple
+    }
+
+
+class _Module:
+    """
+    A Python module.
+    """
+
+    def __init__(self, name: str) -> None:
+        """
+        Args:
+            name: The fully qualified name of a Python module, e.g. 'package.foo.bar'.
+        """
+        self.name = name
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, self.__class__):
+            return hash(self) == hash(other)
+        else:
+            return False
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def is_descendant_of(self, module: "_Module") -> bool:
+        return self.name.startswith(f"{module.name}.")
+
+
+@dataclass(frozen=True)
+class _Link:
+    importer: str
+    imported: str
+
+
+# A chain of modules, each of which imports the next.
+if TYPE_CHECKING:
+    # TODO: remove TYPE_CHECKING conditional once on Python 3.9.
+    _Chain = tuple[str, ...]
+
+
+def _generate_module_permutations(
+    graph: ImportGraph,
+    layers: Sequence[str],
+    containers: set[str],
+) -> Iterator[tuple[_Module, _Module, str | None]]:
+    """
+    Return all possible combinations of higher level and lower level modules, in pairs.
+
+    Each pair of modules consists of immediate children of two different layers. The first
+    module is in a layer higher than the layer of the second module. This means the first
+    module is allowed to import the second, but not the other way around.
+
+    Returns:
+        module_in_higher_layer, module_in_lower_layer, container
+    """
+    # If there are no containers, we still want to run the loop once.
+    quasi_containers = containers or [None]
+
+    for container in quasi_containers:
+        for index, higher_layer in enumerate(layers):
+            higher_layer_module = _module_from_layer(higher_layer, container)
+
+            if higher_layer_module.name not in graph.modules:
+                continue
+
+            for lower_layer in layers[index + 1 :]:
+                lower_layer_module = _module_from_layer(lower_layer, container)
+
+                if lower_layer_module.name not in graph.modules:
+                    continue
+
+                yield higher_layer_module, lower_layer_module, container
+
+
+def _module_from_layer(layer: str, container: str | None = None) -> _Module:
+    if container:
+        name = ".".join([container, layer])
+    else:
+        name = layer
+    return _Module(name)

{grimp-3.1 → grimp-3.2}/src/grimp/adaptors/graph.py

@@ -6,7 +6,7 @@ from typing import Dict, List, Optional, Sequence, Set, Tuple, cast
 from grimp.algorithms.shortest_path import bidirectional_shortest_path
 from grimp.application.ports import graph
 from grimp.domain.analysis import PackageDependency
-from grimp.domain.valueobjects import Module
+from grimp.domain.valueobjects import Module, Layer
 from grimp.exceptions import ModuleNotPresent
 
 from . import _layers
@@ -365,9 +365,10 @@ class ImportGraph(graph.ImportGraph):
 
     def find_illegal_dependencies_for_layers(
         self,
-        layers: Sequence[str | set[str]],
-        containers: Optional[set[str]] = None,
+        layers: Sequence[Layer | str | set[str]],
+        containers: set[str] | None = None,
     ) -> set[PackageDependency]:
+        layers = _layers.parse_layers(layers)
         return _layers.find_illegal_dependencies(
             graph=self, layers=layers, containers=containers or set()
         )

{grimp-3.1 → grimp-3.2}/src/grimp/adaptors/modulefinder.py

@@ -74,6 +74,9 @@ class ModuleFinder(modulefinder.AbstractModuleFinder):
         if filename.startswith("."):
             return False
 
+        if not filename.endswith(".py"):
+            return False
+
         # Ignore files like some.module.py.
         if filename.count(".") > 1:
             logger.warning(
@@ -82,7 +85,7 @@ class ModuleFinder(modulefinder.AbstractModuleFinder):
             )
             return False
 
-        return filename.endswith(".py")
+        return True
 
     def _module_name_from_filename(
         self, package_name: str, filename_and_path: str, package_directory: str

{grimp-3.1 → grimp-3.2}/src/grimp/application/ports/graph.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
 import abc
-from typing import Iterator, List, Optional, Sequence, Set, Tuple, Union
+from typing import Iterator, List, Optional, Sequence, Set, Tuple
 
 from typing_extensions import TypedDict
 
 from grimp.domain.analysis import PackageDependency
+from grimp.domain.valueobjects import Layer
 
 
 class DetailedImport(TypedDict):
@@ -271,25 +272,29 @@ class ImportGraph(abc.ABC):
 
     def find_illegal_dependencies_for_layers(
         self,
-        layers: Sequence[Union[str, set[str]]],
-        containers: Optional[set[str]] = None,
+        layers: Sequence[Layer | str | set[str]],
+        containers: set[str] | None = None,
     ) -> set[PackageDependency]:
         """
         Find dependencies that don't conform to the supplied layered architecture.
 
-        'Layers' is an architectural pattern in which a list of sibling modules/packages
+        'Layers' is an architectural pattern in which a list of modules/packages
         have a dependency direction from high to low. In other words, a higher layer would
         be allowed to import a lower layer, but not the other way around.
 
-        Additionally, multiple layers can be grouped together at the same level; for example
-        `mypackage.utils` and `mypackage.logging` might sit at the bottom, so they cannot
-        import from any other layers. Layers at the same level must be independent, so any
-        dependencies in either direction will be treated as illegal.
+        Additionally, multiple modules can be grouped together at the same layer;
+        for example `mypackage.utils` and `mypackage.logging` might sit at the bottom, so they
+        cannot import from any other layers. To specify that multiple modules should
+        be treated as siblings within a single layer, pass a `Layer`. The `Layer.independent`
+        field can be used to specify whether the sibling modules should be treated as independent
+        - should imports between sibling modules be forbidden (default) or allowed? For backwards
+        compatibility it is also possible to pass a simple `set[str]` to describe a layer. In this
+        case the sibling modules within the layer will be considered independent.
 
         Arguments:
 
-        - layers:     A sequence, each element of which consists either of the name of a layer
-                      module, or a set of sibling layers that at the same level. If containers
+        - layers:     A sequence, each element of which consists either of a `Layer`, the name
+                      of a layer module or a set of sibling modules. If containers
                       are also specified, then these names must be relative to the container.
                       The order is from higher to lower level layers. Any layers that don't
                       exist in the graph will be ignored.

{grimp-3.1 → grimp-3.2}/src/grimp/domain/valueobjects.py

@@ -84,3 +84,23 @@ class DirectImport(ValueObject):
 
     def __hash__(self) -> int:
         return hash((str(self), self.line_contents))
+
+
+class Layer(ValueObject):
+    """
+    A layer within a layered architecture.
+
+    If layer.independent is True then the modules within the layer are considered
+    independent. This is the default.
+    """
+
+    def __init__(
+        self,
+        *module_tails: str,
+        independent: bool = True,
+    ) -> None:
+        self.module_tails = set(module_tails)
+        self.independent = independent
+
+    def __str__(self) -> str:
+        return f"{self.module_tails}, independent={self.independent}"

grimp-3.1/src/grimp/adaptors/_layers.py

@@ -1,353 +0,0 @@
-from __future__ import annotations
-
-import copy
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Iterator, Sequence, TypedDict, Union
-
-from grimp import Route
-from grimp import _rustgrimp as rust  # type: ignore[attr-defined]
-
-if TYPE_CHECKING:
-    from grimp.adaptors.graph import ImportGraph
-
-from grimp.domain.analysis import PackageDependency
-from grimp.exceptions import NoSuchContainer
-
-
-def find_illegal_dependencies(
-    graph: ImportGraph,
-    layers: Sequence[Union[str, set[str]]],
-    containers: set[str],
-) -> set[PackageDependency]:
-    """
-    Find dependencies that don't conform to the supplied layered architecture.
-
-    See ImportGraph.find_illegal_dependencies_for_layers.
-
-    The only difference between this and the method is that the containers passed in
-    is already a (potentially empty) set.
-    """
-    try:
-        rust_package_dependency_tuple = rust.find_illegal_dependencies(
-            levels=_layers_to_levels(layers),
-            containers=set(containers),
-            importeds_by_importer=graph._importeds_by_importer,
-        )
-    except rust.NoSuchContainer as e:
-        raise NoSuchContainer(str(e))
-
-    rust_package_dependencies = _dependencies_from_tuple(rust_package_dependency_tuple)
-    return rust_package_dependencies
-
-
-class _RustRoute(TypedDict):
-    heads: frozenset[str]
-    middle: tuple[str, ...]
-    tails: frozenset[str]
-
-
-class _RustPackageDependency(TypedDict):
-    importer: str
-    imported: str
-    routes: tuple[_RustRoute, ...]
-
-
-def _layers_to_levels(layers: Sequence[Union[str, set[str]]]) -> tuple[set[str], ...]:
-    """
-    Convert any standalone layers to a one-element level.
-    """
-    return tuple({layer} if isinstance(layer, str) else set(layer) for layer in layers)
-
-
-def _dependencies_from_tuple(
-    rust_package_dependency_tuple: tuple[_RustPackageDependency, ...]
-) -> set[PackageDependency]:
-    return {
-        PackageDependency(
-            imported=dep_dict["imported"],
-            importer=dep_dict["importer"],
-            routes=frozenset(
-                {
-                    Route(
-                        heads=route_dict["heads"],
-                        middle=route_dict["middle"],
-                        tails=route_dict["tails"],
-                    )
-                    for route_dict in dep_dict["routes"]
-                }
-            ),
-        )
-        for dep_dict in rust_package_dependency_tuple
-    }
-
-
-class _Module:
-    """
-    A Python module.
-    """
-
-    def __init__(self, name: str) -> None:
-        """
-        Args:
-            name: The fully qualified name of a Python module, e.g. 'package.foo.bar'.
-        """
-        self.name = name
-
-    def __str__(self) -> str:
-        return self.name
-
-    def __eq__(self, other: Any) -> bool:
-        if isinstance(other, self.__class__):
-            return hash(self) == hash(other)
-        else:
-            return False
-
-    def __hash__(self) -> int:
-        return hash(str(self))
-
-    def is_descendant_of(self, module: "_Module") -> bool:
-        return self.name.startswith(f"{module.name}.")
-
-
-@dataclass(frozen=True)
-class _Link:
-    importer: str
-    imported: str
-
-
-# A chain of modules, each of which imports the next.
-if TYPE_CHECKING:
-    # TODO: remove TYPE_CHECKING conditional once on Python 3.9.
-    _Chain = tuple[str, ...]
-
-
-def _generate_module_permutations(
-    graph: ImportGraph,
-    layers: Sequence[str],
-    containers: set[str],
-) -> Iterator[tuple[_Module, _Module, str | None]]:
-    """
-    Return all possible combinations of higher level and lower level modules, in pairs.
-
-    Each pair of modules consists of immediate children of two different layers. The first
-    module is in a layer higher than the layer of the second module. This means the first
-    module is allowed to import the second, but not the other way around.
-
-    Returns:
-        module_in_higher_layer, module_in_lower_layer, container
-    """
-    # If there are no containers, we still want to run the loop once.
-    quasi_containers = containers or [None]
-
-    for container in quasi_containers:
-        for index, higher_layer in enumerate(layers):
-            higher_layer_module = _module_from_layer(higher_layer, container)
-
-            if higher_layer_module.name not in graph.modules:
-                continue
-
-            for lower_layer in layers[index + 1 :]:
-                lower_layer_module = _module_from_layer(lower_layer, container)
-
-                if lower_layer_module.name not in graph.modules:
-                    continue
-
-                yield higher_layer_module, lower_layer_module, container
-
-
-def _module_from_layer(layer: str, container: str | None = None) -> _Module:
-    if container:
-        name = ".".join([container, layer])
-    else:
-        name = layer
-    return _Module(name)
-
-
-def _search_for_package_dependency(
-    higher_layer_package: _Module,
-    lower_layer_package: _Module,
-    layers: Sequence[str],
-    container: str | None,
-    graph: ImportGraph,
-) -> PackageDependency | None:
-    """
-    Return a PackageDependency containing illegal chains between two layers, if they exist.
-    """
-    temp_graph = copy.deepcopy(graph)
-    _remove_other_layers(
-        temp_graph,
-        layers=layers,
-        container=container,
-        layers_to_preserve=(higher_layer_package, lower_layer_package),
-    )
-    # Assemble direct imports between the layers, then remove them.
-    import_details_between_layers = _pop_direct_imports(
-        higher_layer_package=higher_layer_package,
-        lower_layer_package=lower_layer_package,
-        graph=temp_graph,
-    )
-    routes: set[Route] = set()
-
-    for import_details_list in import_details_between_layers:
-        any_element = tuple(import_details_list)[0]
-        routes.add(
-            Route(
-                heads=frozenset({any_element.importer}),
-                middle=(),
-                tails=frozenset({any_element.imported}),
-            )
-        )
-
-    indirect_routes = _get_indirect_routes(
-        temp_graph,
-        importer_package=lower_layer_package,
-        imported_package=higher_layer_package,
-    )
-
-    routes |= indirect_routes
-
-    if routes:
-        return PackageDependency(
-            importer=lower_layer_package.name,
-            imported=higher_layer_package.name,
-            routes=frozenset(routes),
-        )
-    else:
-        return None
-
-
-def _get_indirect_routes(
-    graph: ImportGraph, importer_package: _Module, imported_package: _Module
-) -> set[Route]:
-    """
-    Squashes the two packages.
-    Gets a list of paths between them, called segments.
-    Add the heads and tails to the segments.
-    """
-    temp_graph = copy.deepcopy(graph)
-
-    temp_graph.squash_module(importer_package.name)
-    temp_graph.squash_module(imported_package.name)
-
-    middles = _find_middles(
-        temp_graph,
-        importer=importer_package,
-        imported=imported_package,
-    )
-    return _middles_to_routes(graph, middles, importer=importer_package, imported=imported_package)
-
-
-def _remove_other_layers(
-    graph: ImportGraph,
-    layers: Sequence[str],
-    container: str | None,
-    layers_to_preserve: tuple[_Module, ...],
-) -> None:
-    for index, layer in enumerate(layers):  # type: ignore
-        candidate_layer = _module_from_layer(layer, container)
-        if candidate_layer.name in graph.modules and candidate_layer not in layers_to_preserve:
-            _remove_layer(graph, layer_package=candidate_layer)
-
-
-def _remove_layer(graph: ImportGraph, layer_package: _Module) -> None:
-    for module in graph.find_descendants(layer_package.name):
-        graph.remove_module(module)
-    graph.remove_module(layer_package.name)
-
-
-def _pop_direct_imports(
-    higher_layer_package, lower_layer_package, graph: ImportGraph
-) -> set[frozenset[_Link]]:
-    import_details_set: set[frozenset[_Link]] = set()
-
-    lower_layer_modules = {lower_layer_package.name} | graph.find_descendants(
-        lower_layer_package.name
-    )
-    for lower_layer_module in lower_layer_modules:
-        imported_modules = graph.find_modules_directly_imported_by(lower_layer_module).copy()
-        for imported_module in imported_modules:
-            if _Module(imported_module) == higher_layer_package or _Module(
-                imported_module
-            ).is_descendant_of(higher_layer_package):
-                import_details = frozenset(
-                    {
-                        _Link(
-                            importer=lower_layer_module,
-                            imported=imported_module,
-                        ),
-                    }
-                )
-                import_details_set.add(import_details)
-                graph.remove_import(importer=lower_layer_module, imported=imported_module)
-    return import_details_set
-
-
-def _find_middles(graph: ImportGraph, importer: _Module, imported: _Module) -> set[_Chain]:
-    """
-    Return set of headless and tailless chains.
-    """
-    middles: set[_Chain] = set()
-
-    for chain in _pop_shortest_chains(graph, importer=importer.name, imported=imported.name):
-        if len(chain) == 2:
-            raise ValueError("Direct chain found - these should have been removed.")
-        middles.add(chain[1:-1])
-
-    return middles
-
-
-def _middles_to_routes(
-    graph: ImportGraph, middles: set[_Chain], importer: _Module, imported: _Module
-) -> set[Route]:
-    """
-    Build a set of routes from the chains between one package and another.
-
-    The middles are the chains that exist from the importer package to
-    the importer package. This function works out the head and tail packages of
-    those chains by consulting the graph.
-    """
-    routes: set[Route] = set()
-
-    for middle in middles:
-        heads: set[str] = set()
-        imported_module = middle[0]
-        candidate_modules = sorted(graph.find_modules_that_directly_import(imported_module))
-        for module in [
-            m
-            for m in candidate_modules
-            if _Module(m) == importer or _Module(m).is_descendant_of(importer)
-        ]:
-            heads.add(module)
-
-        tails: set[str] = set()
-        importer_module = middle[-1]
-        candidate_modules = sorted(graph.find_modules_directly_imported_by(importer_module))
-        for module in [
-            m
-            for m in candidate_modules
-            if _Module(m) == imported or _Module(m).is_descendant_of(imported)
-        ]:
-            tails.add(module)
-
-        routes.add(
-            Route(
-                heads=frozenset(heads),
-                middle=middle,
-                tails=frozenset(tails),
-            )
-        )
-
-    return routes
-
-
-def _pop_shortest_chains(
-    graph: ImportGraph, importer: str, imported: str
-) -> Iterator[tuple[str, ...]]:
-    chain: tuple[str, ...] | bool | None = True
-    while chain:
-        chain = graph.find_shortest_chain(importer, imported)
-        if chain:
-            # Remove chain of imports from graph.
-            for index in range(len(chain) - 1):
-                graph.remove_import(importer=chain[index], imported=chain[index + 1])
-            yield chain