grimp 3.1__tar.gz → 3.3__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: grimp
-Version: 3.1
+Version: 3.3
 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.3}/pyproject.toml

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

{grimp-3.1 → 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.1 → 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.1 → 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.1 → grimp-3.3}/rust/src/layers.rs

@@ -2,53 +2,53 @@ 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.
-/// These layers should be independent.
 #[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
+/// in which the second should not import the first.
 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![];
 
@@ -69,13 +69,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);
+                        }
                     }
                 }
 
@@ -157,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
 }
@@ -333,13 +338,20 @@ mod tests {
         ]));
         let levels = vec![
             Level {
-                layers: vec!["high"],
+                independent: true,
+                layers: vec!["high".to_string()],
             },
             Level {
-                layers: vec!["mid_a", "mid_b", "mid_c"],
+                independent: true,
+                layers: vec![
+                    "mid_a".to_string(),
+                    "mid_b".to_string(),
+                    "mid_c".to_string(),
+                ],
             },
             Level {
-                layers: vec!["low"],
+                independent: true,
+                layers: vec!["low".to_string()],
             },
         ];
         let containers = HashSet::new();
@@ -405,13 +417,15 @@ mod tests {
         ]));
         let levels = vec![
             Level {
-                layers: vec!["high"],
+                independent: true,
+                layers: vec!["high".to_string()],
             },
             Level {
-                layers: vec!["low"],
+                independent: true,
+                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);
 
@@ -460,16 +474,23 @@ mod tests {
         ]));
         let levels = vec![
             Level {
-                layers: vec!["high"],
+                independent: true,
+                layers: vec!["high".to_string()],
             },
             Level {
-                layers: vec!["mid_a", "mid_b", "mid_c"],
+                independent: true,
+                layers: vec![
+                    "mid_a".to_string(),
+                    "mid_b".to_string(),
+                    "mid_c".to_string(),
+                ],
             },
             Level {
-                layers: vec!["low"],
+                independent: true,
+                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);
 
@@ -553,17 +574,118 @@ 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".to_string()],
+            },
+            Level {
+                independent: false,
+                layers: vec![
+                    "mid_a".to_string(),
+                    "mid_b".to_string(),
+                    "mid_c".to_string(),
+                ],
+            },
+            Level {
+                independent: true,
+                layers: vec!["low".to_string()],
+            },
+        ];
+        let containers = HashSet::from(["mypackage".to_string()]);
+
+        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 {
-                layers: vec!["high"],
+                independent: true,
+                layers: vec!["high".to_string()],
             },
             Level {
-                layers: vec!["medium_a", "medium_b", "medium_c"],
+                independent: true,
+                layers: vec![
+                    "medium_a".to_string(),
+                    "medium_b".to_string(),
+                    "medium_c".to_string(),
+                ],
             },
             Level {
-                layers: vec!["low"],
+                independent: true,
+                layers: vec!["low".to_string()],
             },
         ];