grimp 3.0b3__tar.gz → 3.2__tar.gz

{grimp-3.0b3 → grimp-3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: grimp
-Version: 3.0b3
+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.0b3 → grimp-3.2}/pyproject.toml

@@ -8,7 +8,7 @@ module-name = "grimp._rustgrimp"
 
 [project]
 name = "grimp"
-version = "3.0b3"
+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",
@@ -52,4 +53,5 @@ where = ["src"]
 namespaces = false
 
 [tool.black]
-line-length = 99
+line-length = 99
+exclude = 'tests/assets/syntaxerrorpackage'

{grimp-3.0b3 → 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.0b3 → 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.0b3 → 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.0b3 → grimp-3.2}/src/grimp/__init__.py

@@ -1,8 +1,8 @@
-__version__ = "3.0b3"
+__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.0b3 → grimp-3.2}/src/grimp/adaptors/caching.py

@@ -21,24 +21,28 @@ class CacheFileNamer:
 
     @classmethod
     def make_data_file_name(
-        cls, found_packages: Set[FoundPackage], include_external_packages: bool
+        cls,
+        found_packages: Set[FoundPackage],
+        include_external_packages: bool,
+        exclude_type_checking_imports: bool,
     ) -> str:
         identifier = cls.make_data_file_unique_string(
-            found_packages, include_external_packages
+            found_packages, include_external_packages, exclude_type_checking_imports
         )
 
         bytes_identifier = identifier.encode()
         # Use a hash algorithm with a limited size to avoid cache filenames that are too long
         # the filesystem, which can happen if there are more than a few root packages
         # being analyzed.
-        safe_unicode_identifier = hashlib.blake2b(
-            bytes_identifier, digest_size=20
-        ).hexdigest()
+        safe_unicode_identifier = hashlib.blake2b(bytes_identifier, digest_size=20).hexdigest()
         return f"{safe_unicode_identifier}.data.json"
 
     @classmethod
     def make_data_file_unique_string(
-        cls, found_packages: Set[FoundPackage], include_external_packages: bool
+        cls,
+        found_packages: Set[FoundPackage],
+        include_external_packages: bool,
+        exclude_type_checking_imports: bool,
     ) -> str:
         """
         Construct a unique string that identifies the analysis parameters.
@@ -47,10 +51,13 @@ class CacheFileNamer:
         """
         package_names = (p.name for p in found_packages)
         csv_packages = ",".join(sorted(package_names))
-        include_external_packages_option = (
-            ":external" if include_external_packages else ""
+        include_external_packages_option = ":external" if include_external_packages else ""
+        exclude_type_checking_imports_option = (
+            ":no_type_checking" if exclude_type_checking_imports else ""
+        )
+        return (
+            csv_packages + include_external_packages_option + exclude_type_checking_imports_option
         )
-        return csv_packages + include_external_packages_option
 
 
 class Cache(AbstractCache):
@@ -71,6 +78,7 @@ class Cache(AbstractCache):
         file_system: AbstractFileSystem,
         found_packages: Set[FoundPackage],
         include_external_packages: bool,
+        exclude_type_checking_imports: bool = False,
         cache_dir: Optional[str] = None,
         namer: Type[CacheFileNamer] = CacheFileNamer,
     ) -> "Cache":
@@ -78,6 +86,7 @@ class Cache(AbstractCache):
             file_system=file_system,
             found_packages=found_packages,
             include_external_packages=include_external_packages,
+            exclude_type_checking_imports=exclude_type_checking_imports,
             cache_dir=cls.cache_dir_or_default(cache_dir),
             namer=namer,
         )
@@ -132,6 +141,7 @@ class Cache(AbstractCache):
             self._namer.make_data_file_name(
                 found_packages=self.found_packages,
                 include_external_packages=self.include_external_packages,
+                exclude_type_checking_imports=self.exclude_type_checking_imports,
             ),
         )
         self.file_system.write(data_cache_filename, serialized)
@@ -185,6 +195,7 @@ class Cache(AbstractCache):
             self._namer.make_data_file_name(
                 found_packages=self.found_packages,
                 include_external_packages=self.include_external_packages,
+                exclude_type_checking_imports=self.exclude_type_checking_imports,
             ),
         )
         try:
@@ -201,9 +212,7 @@ class Cache(AbstractCache):
             logger.warning(f"Could not use corrupt cache file {data_cache_filename}.")
             return {}
 
-        primitives_map: PrimitiveFormat = self._to_primitives_data_map(
-            deserialized_json
-        )
+        primitives_map: PrimitiveFormat = self._to_primitives_data_map(deserialized_json)
 
         return {
             Module(name=name): {

{grimp-3.0b3 → 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()
         )