grimp 3.2__tar.gz → 3.3__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: grimp
-Version: 3.2
+Version: 3.3
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License

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

@@ -8,7 +8,7 @@ module-name = "grimp._rustgrimp"
 
 [project]
 name = "grimp"
-version = "3.2"
+version = "3.3"
 license = {text = "BSD 2-Clause License"}
 description = "Builds a queryable graph of the imports within one or more Python packages."
 authors = [
@@ -54,4 +54,4 @@ namespaces = false
 
 [tool.black]
 line-length = 99
-exclude = 'tests/assets/syntaxerrorpackage'
+exclude = 'tests/assets/syntaxerrorpackage'

{grimp-3.2 → grimp-3.3}/rust/Cargo.lock

@@ -9,6 +9,7 @@ dependencies = [
  "log",
  "pyo3",
  "pyo3-log",
+ "rayon",
  "serde_json",
 ]
 
@@ -36,11 +37,48 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+
+[[package]]
+name = "either"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385b58b"
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
 [[package]]
 name = "indoc"
-version = "1.0.9"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa799dd5ed20a7e349f3b4639aa80d74549c81716d9ec4f994c9b5815598306"
+checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
 
 [[package]]
 name = "itoa"
@@ -108,6 +146,12 @@ dependencies = [
  "windows-targets",
 ]
 
+[[package]]
+name = "portable-atomic"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.64"
@@ -119,15 +163,16 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.19.1"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffb88ae05f306b4bfcde40ac4a51dc0b05936a9207a4b75b798c7729c4258a59"
+checksum = "a5e00b96a521718e08e03b1a622f01c8a8deb50719335de3f60b3b3950f069d8"
 dependencies = [
  "cfg-if",
  "indoc",
  "libc",
  "memoffset",
  "parking_lot",
+ "portable-atomic",
  "pyo3-build-config",
  "pyo3-ffi",
  "pyo3-macros",
@@ -136,9 +181,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.19.1"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "554db24f0b3c180a9c0b1268f91287ab3f17c162e15b54caaae5a6b3773396b0"
+checksum = "7883df5835fafdad87c0d888b266c8ec0f4c9ca48a5bed6bbb592e8dedee1b50"
 dependencies = [
  "once_cell",
  "target-lexicon",
@@ -146,9 +191,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.19.1"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "922ede8759e8600ad4da3195ae41259654b9c55da4f7eec84a0ccc7d067a70a4"
+checksum = "01be5843dc60b916ab4dad1dca6d20b9b4e6ddc8e15f50c47fe6d85f1fb97403"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -156,9 +201,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-log"
-version = "0.8.3"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f47b0777feb17f61eea78667d61103758b243a871edc09a7786500a50467b605"
+checksum = "2af49834b8d2ecd555177e63b273b708dea75150abc6f5341d0a6e1a9623976c"
 dependencies = [
  "arc-swap",
  "log",
@@ -167,9 +212,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.19.1"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a5caec6a1dd355964a841fcbeeb1b89fe4146c87295573f94228911af3cc5a2"
+checksum = "77b34069fc0682e11b31dbd10321cbf94808394c56fd996796ce45217dfac53c"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -179,11 +224,13 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.19.1"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0b78ccbb160db1556cdb6fd96c50334c5d4ec44dc5e0a968d0a1208fa0efa8b"
+checksum = "08260721f32db5e1a5beae69a55553f56b99bd0e1c3e6e0a5e8851a9d0f5a85c"
 dependencies = [
+ "heck",
  "proc-macro2",
+ "pyo3-build-config",
  "quote",
  "syn",
 ]
@@ -197,6 +244,26 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.3.5"
@@ -243,9 +310,9 @@ checksum = "62bb4feee49fdd9f707ef802e22365a35de4b7b299de4763d44bfea899442ff9"
 
 [[package]]
 name = "syn"
-version = "1.0.109"
+version = "2.0.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+checksum = "239814284fd6f1a4ffe4ca893952cdd93c224b6a1571c9a9eadd670295c0c9e2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -266,9 +333,9 @@ checksum = "22049a19f4a68748a168c0fc439f9516686aa045927ff767eca0a85101fb6e73"
 
 [[package]]
 name = "unindent"
-version = "0.1.11"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c"
+checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
 
 [[package]]
 name = "windows-targets"

{grimp-3.2 → grimp-3.3}/rust/Cargo.toml

@@ -9,11 +9,12 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 log = "0.4.19"
-pyo3-log = "0.8.3"
+pyo3-log = "0.10.0"
 serde_json = "1.0.103"
+rayon = "1.10"
 
 [dependencies.pyo3]
-version = "0.19.1"
+version = "0.21.2"
 
 [features]
 extension-module = ["pyo3/extension-module"]

{grimp-3.2 → grimp-3.3}/rust/src/containers.rs

@@ -1,10 +1,9 @@
 use crate::importgraph::ImportGraph;
 use std::collections::HashSet;
 
-
 pub fn check_containers_exist<'a>(
     graph: &'a ImportGraph,
-    containers: &'a HashSet<&'a str>,
+    containers: &'a HashSet<String>,
 ) -> Result<(), String> {
     for container in containers {
         if !graph.contains_module(container) {

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

@@ -2,47 +2,45 @@ use crate::dependencies::{PackageDependency, Route};
 use crate::importgraph::ImportGraph;
 
 use log::info;
+use rayon::prelude::*;
 use std::collections::HashSet;
 use std::time::Instant;
 
 /// A group of layers at the same level in the layering.
 #[derive(PartialEq, Eq, Hash, Debug)]
-pub struct Level<'a> {
-    pub layers: Vec<&'a str>,
+pub struct Level {
+    pub layers: Vec<String>,
     pub independent: bool,
 }
 
 pub fn find_illegal_dependencies<'a>(
     graph: &'a ImportGraph,
     levels: &'a Vec<Level>,
-    containers: &'a HashSet<&'a str>,
+    containers: &'a HashSet<String>,
 ) -> Vec<PackageDependency> {
-    let mut dependencies: Vec<PackageDependency> = vec![];
     let layers = _layers_from_levels(levels);
 
-    for (higher_layer_package, lower_layer_package, container) in
-        _generate_module_permutations(graph, levels, containers)
-    {
-        // TODO: it's inefficient to do this for sibling layers, as we don't need
-        // to clone and trim the graph for identical pairs.
-        info!(
-            "Searching for import chains from {} to {}...",
-            lower_layer_package, higher_layer_package
-        );
-        let now = Instant::now();
-        let dependency_or_none = _search_for_package_dependency(
-            &higher_layer_package,
-            &lower_layer_package,
-            &layers,
-            &container,
-            graph,
-        );
-        _log_illegal_route_count(&dependency_or_none, now.elapsed().as_secs());
-        if let Some(dependency) = dependency_or_none {
-            dependencies.push(dependency);
-        }
-    }
-    dependencies
+    _generate_module_permutations(graph, levels, containers)
+        .into_par_iter()
+        .filter_map(|(higher_layer_package, lower_layer_package, container)| {
+            // TODO: it's inefficient to do this for sibling layers, as we don't need
+            // to clone and trim the graph for identical pairs.
+            info!(
+                "Searching for import chains from {} to {}...",
+                lower_layer_package, higher_layer_package
+            );
+            let now = Instant::now();
+            let dependency_or_none = _search_for_package_dependency(
+                &higher_layer_package,
+                &lower_layer_package,
+                &layers,
+                &container,
+                graph,
+            );
+            _log_illegal_route_count(&dependency_or_none, now.elapsed().as_secs());
+            dependency_or_none
+        })
+        .collect()
 }
 
 /// Return every permutation of modules that exist in the graph
@@ -50,7 +48,7 @@ pub fn find_illegal_dependencies<'a>(
 fn _generate_module_permutations<'a>(
     graph: &'a ImportGraph,
     levels: &'a [Level],
-    containers: &'a HashSet<&'a str>,
+    containers: &'a HashSet<String>,
 ) -> Vec<(String, String, Option<String>)> {
     let mut permutations: Vec<(String, String, Option<String>)> = vec![];
 
@@ -71,7 +69,7 @@ fn _generate_module_permutations<'a>(
                     continue;
                 }
 
-                // Build the layers that mustn't import this higher layer. 
+                // Build the layers that mustn't import this higher layer.
                 // That includes:
                 // * lower layers.
                 // * sibling layers, if the layer is independent.
@@ -164,7 +162,7 @@ fn _search_for_package_dependency<'a>(
 fn _layers_from_levels<'a>(levels: &'a Vec<Level>) -> Vec<&'a str> {
     let mut layers: Vec<&str> = vec![];
     for level in levels {
-        layers.extend(level.layers.iter());
+        layers.extend(level.layers.iter().map(|s| s.as_str()));
     }
     layers
 }
@@ -341,15 +339,19 @@ mod tests {
         let levels = vec![
             Level {
                 independent: true,
-                layers: vec!["high"],
+                layers: vec!["high".to_string()],
             },
             Level {
                 independent: true,
-                layers: vec!["mid_a", "mid_b", "mid_c"],
+                layers: vec![
+                    "mid_a".to_string(),
+                    "mid_b".to_string(),
+                    "mid_c".to_string(),
+                ],
             },
             Level {
                 independent: true,
-                layers: vec!["low"],
+                layers: vec!["low".to_string()],
             },
         ];
         let containers = HashSet::new();
@@ -416,14 +418,14 @@ mod tests {
         let levels = vec![
             Level {
                 independent: true,
-                layers: vec!["high"],
+                layers: vec!["high".to_string()],
             },
             Level {
                 independent: true,
-                layers: vec!["low"],
+                layers: vec!["low".to_string()],
             },
         ];
-        let containers = HashSet::from(["mypackage"]);
+        let containers = HashSet::from(["mypackage".to_string()]);
 
         let dependencies = find_illegal_dependencies(&graph, &levels, &containers);
 
@@ -473,18 +475,22 @@ mod tests {
         let levels = vec![
             Level {
                 independent: true,
-                layers: vec!["high"],
+                layers: vec!["high".to_string()],
             },
             Level {
                 independent: true,
-                layers: vec!["mid_a", "mid_b", "mid_c"],
+                layers: vec![
+                    "mid_a".to_string(),
+                    "mid_b".to_string(),
+                    "mid_c".to_string(),
+                ],
             },
             Level {
                 independent: true,
-                layers: vec!["low"],
+                layers: vec!["low".to_string()],
             },
         ];
-        let containers = HashSet::from(["mypackage"]);
+        let containers = HashSet::from(["mypackage".to_string()]);
 
         let perms = _generate_module_permutations(&graph, &levels, &containers);
 
@@ -593,18 +599,22 @@ mod tests {
         let levels = vec![
             Level {
                 independent: true,
-                layers: vec!["high"],
+                layers: vec!["high".to_string()],
             },
             Level {
                 independent: false,
-                layers: vec!["mid_a", "mid_b", "mid_c"],
+                layers: vec![
+                    "mid_a".to_string(),
+                    "mid_b".to_string(),
+                    "mid_c".to_string(),
+                ],
             },
             Level {
                 independent: true,
-                layers: vec!["low"],
+                layers: vec!["low".to_string()],
             },
         ];
-        let containers = HashSet::from(["mypackage"]);
+        let containers = HashSet::from(["mypackage".to_string()]);
 
         let perms = _generate_module_permutations(&graph, &levels, &containers);
 
@@ -663,15 +673,19 @@ mod tests {
         let levels = vec![
             Level {
                 independent: true,
-                layers: vec!["high"],
+                layers: vec!["high".to_string()],
             },
             Level {
                 independent: true,
-                layers: vec!["medium_a", "medium_b", "medium_c"],
+                layers: vec![
+                    "medium_a".to_string(),
+                    "medium_b".to_string(),
+                    "medium_c".to_string(),
+                ],
             },
             Level {
                 independent: true,
-                layers: vec!["low"],
+                layers: vec!["low".to_string()],
             },
         ];
 

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

@@ -12,47 +12,79 @@ use log::info;
 use pyo3::create_exception;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyFrozenSet, PySet, PyString, PyTuple};
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 
 #[pymodule]
-fn _rustgrimp(_py: Python, m: &PyModule) -> PyResult<()> {
+fn _rustgrimp(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     pyo3_log::init();
 
     m.add_function(wrap_pyfunction!(find_illegal_dependencies, m)?)?;
-    m.add("NoSuchContainer", _py.get_type::<NoSuchContainer>())?;
+    m.add("NoSuchContainer", py.get_type_bound::<NoSuchContainer>())?;
     Ok(())
 }
 
 create_exception!(_rustgrimp, NoSuchContainer, pyo3::exceptions::PyException);
 
 #[pyfunction]
-pub fn find_illegal_dependencies<'a>(
-    py: Python<'a>,
-    levels: &'a PyTuple,
-    containers: &'a PySet,
-    importeds_by_importer: &'a PyDict,
-) -> PyResult<&'a PyTuple> {
+pub fn find_illegal_dependencies<'py>(
+    py: Python<'py>,
+    levels: &Bound<'py, PyTuple>,
+    containers: &Bound<'py, PySet>,
+    importeds_by_importer: &Bound<'py, PyDict>,
+) -> PyResult<Bound<'py, PyTuple>> {
     info!("Using Rust to find illegal dependencies.");
-    let graph = ImportGraph::new(importeds_by_importer.extract()?);
 
+    let importeds_by_importer_strings: HashMap<String, HashSet<String>> =
+        importeds_by_importer.extract()?;
+    let importeds_by_importer_strs = strings_to_strs_hashmap(&importeds_by_importer_strings);
+
+    let graph = ImportGraph::new(importeds_by_importer_strs);
     let levels_rust = rustify_levels(levels);
-    let containers_rust: HashSet<&str> = containers.extract()?;
+    let containers_rust: HashSet<String> = containers.extract()?;
 
     if let Err(err) = check_containers_exist(&graph, &containers_rust) {
         return Err(NoSuchContainer::new_err(err));
     }
 
-    let dependencies = layers::find_illegal_dependencies(&graph, &levels_rust, &containers_rust);
+    let dependencies = py.allow_threads(|| {
+        layers::find_illegal_dependencies(&graph, &levels_rust, &containers_rust)
+    });
 
     convert_dependencies_to_python(py, dependencies, &graph)
 }
 
-fn rustify_levels(levels_python: &PyTuple) -> Vec<Level> {
+fn strings_to_strs_hashmap<'a>(
+    string_map: &'a HashMap<String, HashSet<String>>,
+) -> HashMap<&'a str, HashSet<&'a str>> {
+    let mut str_map: HashMap<&str, HashSet<&str>> = HashMap::new();
+
+    for (key, set) in string_map {
+        let mut str_set: HashSet<&str> = HashSet::new();
+        for item in set.iter() {
+            str_set.insert(item);
+        }
+        str_map.insert(key.as_str(), str_set);
+    }
+    str_map
+}
+
+fn rustify_levels<'a>(levels_python: &Bound<'a, PyTuple>) -> Vec<Level> {
     let mut rust_levels: Vec<Level> = vec![];
     for level_python in levels_python.into_iter() {
         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();
+        let layers: HashSet<String> = level_dict
+            .get_item("layers")
+            .unwrap()
+            .unwrap()
+            .extract()
+            .unwrap();
+
+        let independent: bool = level_dict
+            .get_item("independent")
+            .unwrap()
+            .unwrap()
+            .extract()
+            .unwrap();
         rust_levels.push(Level {
             independent,
             layers: layers.into_iter().collect(),
@@ -61,47 +93,47 @@ fn rustify_levels(levels_python: &PyTuple) -> Vec<Level> {
     rust_levels
 }
 
-fn convert_dependencies_to_python<'a>(
-    py: Python<'a>,
+fn convert_dependencies_to_python<'py>(
+    py: Python<'py>,
     dependencies: Vec<PackageDependency>,
     graph: &ImportGraph,
-) -> PyResult<&'a PyTuple> {
-    let mut python_dependencies: Vec<&PyDict> = vec![];
+) -> PyResult<Bound<'py, PyTuple>> {
+    let mut python_dependencies: Vec<Bound<'py, PyDict>> = vec![];
 
     for rust_dependency in dependencies {
-        let python_dependency = PyDict::new(py);
+        let python_dependency = PyDict::new_bound(py);
         python_dependency.set_item("imported", graph.names_by_id[&rust_dependency.imported])?;
         python_dependency.set_item("importer", graph.names_by_id[&rust_dependency.importer])?;
-        let mut python_routes: Vec<&PyDict> = vec![];
+        let mut python_routes: Vec<Bound<'py, PyDict>> = vec![];
         for rust_route in rust_dependency.routes {
-            let route = PyDict::new(py);
-            let heads: Vec<&PyString> = rust_route
+            let route = PyDict::new_bound(py);
+            let heads: Vec<Bound<'py, PyString>> = rust_route
                 .heads
                 .iter()
-                .map(|i| PyString::new(py, graph.names_by_id[&i]))
+                .map(|i| PyString::new_bound(py, graph.names_by_id[&i]))
                 .collect();
-            route.set_item("heads", PyFrozenSet::new(py, &heads)?)?;
-            let middle: Vec<&PyString> = rust_route
+            route.set_item("heads", PyFrozenSet::new_bound(py, &heads)?)?;
+            let middle: Vec<Bound<'py, PyString>> = rust_route
                 .middle
                 .iter()
-                .map(|i| PyString::new(py, graph.names_by_id[&i]))
+                .map(|i| PyString::new_bound(py, graph.names_by_id[&i]))
                 .collect();
-            route.set_item("middle", PyTuple::new(py, &middle))?;
-            let tails: Vec<&PyString> = rust_route
+            route.set_item("middle", PyTuple::new_bound(py, &middle))?;
+            let tails: Vec<Bound<'py, PyString>> = rust_route
                 .tails
                 .iter()
-                .map(|i| PyString::new(py, graph.names_by_id[&i]))
+                .map(|i| PyString::new_bound(py, graph.names_by_id[&i]))
                 .collect();
-            route.set_item("tails", PyFrozenSet::new(py, &tails)?)?;
+            route.set_item("tails", PyFrozenSet::new_bound(py, &tails)?)?;
 
             python_routes.push(route);
         }
 
-        python_dependency.set_item("routes", PyTuple::new(py, python_routes))?;
+        python_dependency.set_item("routes", PyTuple::new_bound(py, python_routes))?;
         python_dependencies.push(python_dependency)
     }
 
-    Ok(PyTuple::new(py, python_dependencies))
+    Ok(PyTuple::new_bound(py, python_dependencies))
 }
 
 #[cfg(test)]
@@ -113,7 +145,7 @@ mod tests {
     macro_rules! pydict {
         ($py: ident, {$($k: expr => $v: expr),*, $(,)?}) => {
             {
-                let dict = PyDict::new($py);
+                let dict = PyDict::new_bound($py);
                 $(
                     dict.set_item($k, $v)?;
                 )*
@@ -126,7 +158,7 @@ mod tests {
     fn test_rustify_levels_no_sibling_layers() {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| -> PyResult<()> {
-            let elements: Vec<&PyDict> = vec![
+            let elements = vec![
                 pydict! (py, {
                     "independent" => true,
                     "layers" => HashSet::from(["high"]),
@@ -138,26 +170,26 @@ mod tests {
                 pydict! (py, {
                     "independent" => true,
                     "layers" => HashSet::from(["low"]),
-                })
+                }),
             ];
-            let python_levels: &PyTuple = PyTuple::new(py, elements);
+            let python_levels = PyTuple::new_bound(py, elements);
 
-            let result = rustify_levels(python_levels);
+            let result = rustify_levels(&python_levels);
 
             assert_eq!(
                 result,
                 vec![
                     Level {
                         independent: true,
-                        layers: vec!["high"]
+                        layers: vec!["high".to_string()]
                     },
                     Level {
                         independent: true,
-                        layers: vec!["medium"]
+                        layers: vec!["medium".to_string()]
                     },
                     Level {
                         independent: true,
-                        layers: vec!["low"]
+                        layers: vec!["low".to_string()]
                     }
                 ]
             );
@@ -171,7 +203,7 @@ mod tests {
     fn test_rustify_levels_sibling_layers() {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| -> PyResult<()> {
-            let elements: Vec<&PyDict> = vec![
+            let elements = vec![
                 pydict! (py, {
                     "independent" => true,
                     "layers" => HashSet::from(["high"]),
@@ -187,11 +219,11 @@ mod tests {
                 pydict! (py, {
                     "independent" => true,
                     "layers" => HashSet::from(["low"]),
-                })
+                }),
             ];
-            let python_levels: &PyTuple = PyTuple::new(py, elements);
+            let python_levels = PyTuple::new_bound(py, elements);
 
-            let mut result = rustify_levels(python_levels);
+            let mut result = rustify_levels(&python_levels);
 
             for level in &mut result {
                 level.layers.sort();
@@ -201,19 +233,23 @@ mod tests {
                 vec![
                     Level {
                         independent: true,
-                        layers: vec!["high"]
+                        layers: vec!["high".to_string()]
                     },
                     Level {
                         independent: true,
-                        layers: vec!["blue", "green", "orange"]
+                        layers: vec![
+                            "blue".to_string(),
+                            "green".to_string(),
+                            "orange".to_string()
+                        ]
                     },
                     Level {
                         independent: false,
-                        layers: vec!["red", "yellow"]
+                        layers: vec!["red".to_string(), "yellow".to_string()]
                     },
                     Level {
                         independent: true,
-                        layers: vec!["low"]
+                        layers: vec!["low".to_string()]
                     }
                 ]
             );

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

@@ -22,26 +22,26 @@ fn test_large_graph() {
     let levels = vec![
         Level {
             independent: true,
-            layers: vec!["plugins"],
+            layers: vec!["plugins".to_string()],
         },
         Level {
             independent: true,
-            layers: vec!["interfaces"],
+            layers: vec!["interfaces".to_string()],
         },
         Level {
             independent: true,
-            layers: vec!["application"],
+            layers: vec!["application".to_string()],
         },
         Level {
             independent: true,
-            layers: vec!["domain"],
+            layers: vec!["domain".to_string()],
         },
         Level {
             independent: true,
-            layers: vec!["data"],
+            layers: vec!["data".to_string()],
         },
     ];
-    let containers = HashSet::from(["mypackage"]);
+    let containers = HashSet::from(["mypackage".to_string()]);
 
     find_illegal_dependencies(&graph, &levels, &containers);
 }

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

@@ -1,4 +1,4 @@
-__version__ = "3.2"
+__version__ = "3.3"
 
 from .application.ports.graph import DetailedImport, ImportGraph
 from .domain.analysis import PackageDependency, Route

{grimp-3.2 → grimp-3.3}/src/grimp/adaptors/filesystem.py

@@ -18,7 +18,7 @@ class FileSystem(AbstractFileSystem):
         return os.path.dirname(filename)
 
     def walk(self, directory_name: str) -> Iterator[Tuple[str, List[str], List[str]]]:
-        yield from os.walk(directory_name)
+        yield from os.walk(directory_name, followlinks=True)
 
     def join(self, *components: str) -> str:
         return os.path.join(*components)