grimp 3.6__tar.gz → 3.7__tar.gz

{grimp-3.6 → grimp-3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grimp
-Version: 3.6
+Version: 3.7
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License

{grimp-3.6 → grimp-3.7}/pyproject.toml

@@ -8,7 +8,7 @@ module-name = "grimp._rustgrimp"
 
 [project]
 name = "grimp"
-version = "3.6"
+version = "3.7"
 license = {text = "BSD 2-Clause License"}
 description = "Builds a queryable graph of the imports within one or more Python packages."
 authors = [

{grimp-3.6 → grimp-3.7}/rust/Cargo.lock

@@ -7,13 +7,16 @@ name = "_rustgrimp"
 version = "0.1.0"
 dependencies = [
  "bimap",
+ "const_format",
  "derive-new",
  "getset",
- "indexmap",
+ "indexmap 2.7.1",
  "itertools",
  "lazy_static",
+ "parameterized",
  "pyo3",
  "rayon",
+ "regex",
  "rustc-hash",
  "serde_json",
  "slotmap",
@@ -22,6 +25,15 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.4.0"
@@ -40,6 +52,26 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "const_format"
+version = "0.2.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "126f97965c8ad46d6d9163268ff28432e8f6a1196a55578867832e3049df63dd"
+dependencies = [
+ "const_format_proc_macros",
+]
+
+[[package]]
+name = "const_format_proc_macros"
+version = "0.2.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.6"
@@ -106,6 +138,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
 [[package]]
 name = "hashbrown"
 version = "0.15.2"
@@ -121,6 +159,16 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.7.1"
@@ -128,7 +176,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652"
 dependencies = [
  "equivalent",
- "hashbrown",
+ "hashbrown 0.15.2",
 ]
 
 [[package]]
@@ -185,6 +233,27 @@ version = "1.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
 
+[[package]]
+name = "parameterized"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "194bf497674dda552d4f1bd24d325f828f425876c9d522fcb1810cd527e0bd4e"
+dependencies = [
+ "parameterized-macro",
+]
+
+[[package]]
+name = "parameterized-macro"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1374bca5edab7a317c4ffbc9df1e239ceb7dcf5426b6b403474408442a9777ac"
+dependencies = [
+ "indexmap 1.9.3",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "portable-atomic"
 version = "1.10.0"
@@ -314,6 +383,35 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
 [[package]]
 name = "rustc-hash"
 version = "2.1.0"
@@ -373,7 +471,7 @@ version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a3275464d7a9f2d4cac57c89c2ef96a8524dba2864c8d6f82e3980baf136f9b"
 dependencies = [
- "hashbrown",
+ "hashbrown 0.15.2",
  "serde",
 ]
 
@@ -426,6 +524,12 @@ version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
 
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
 [[package]]
 name = "unindent"
 version = "0.2.3"

{grimp-3.6 → grimp-3.7}/rust/Cargo.toml

@@ -20,6 +20,8 @@ itertools = "0.14.0"
 tap = "1.0.1"
 rustc-hash = "2.1.0"
 indexmap = "2.7.1"
+regex = "1.11.1"
+const_format = "0.2.34"
 
 [dependencies.pyo3]
 version = "0.23.4"
@@ -29,4 +31,5 @@ extension-module = ["pyo3/extension-module"]
 default = ["extension-module"]
 
 [dev-dependencies]
+parameterized = "2.0.0"
 serde_json = "1.0.137"

{grimp-3.6 → grimp-3.7}/rust/src/errors.rs

@@ -1,4 +1,4 @@
-use crate::exceptions::{ModuleNotPresent, NoSuchContainer};
+use crate::exceptions::{InvalidModuleExpression, ModuleNotPresent, NoSuchContainer};
 use pyo3::exceptions::PyValueError;
 use pyo3::PyErr;
 use thiserror::Error;
@@ -13,6 +13,9 @@ pub enum GrimpError {
 
     #[error("Modules have shared descendants.")]
     SharedDescendants,
+
+    #[error("{0} is not a valid module expression.")]
+    InvalidModuleExpression(String),
 }
 
 pub type GrimpResult<T> = Result<T, GrimpError>;
@@ -24,6 +27,9 @@ impl From<GrimpError> for PyErr {
             GrimpError::ModuleNotPresent(_) => ModuleNotPresent::new_err(value.to_string()),
             GrimpError::NoSuchContainer(_) => NoSuchContainer::new_err(value.to_string()),
             GrimpError::SharedDescendants => PyValueError::new_err(value.to_string()),
+            GrimpError::InvalidModuleExpression(_) => {
+                InvalidModuleExpression::new_err(value.to_string())
+            }
         }
     }
 }

{grimp-3.6 → grimp-3.7}/rust/src/exceptions.rs

@@ -2,3 +2,8 @@ use pyo3::create_exception;
 
 create_exception!(_rustgrimp, ModuleNotPresent, pyo3::exceptions::PyException);
 create_exception!(_rustgrimp, NoSuchContainer, pyo3::exceptions::PyException);
+create_exception!(
+    _rustgrimp,
+    InvalidModuleExpression,
+    pyo3::exceptions::PyException
+);

grimp-3.7/rust/src/graph/direct_import_queries.rs

@@ -0,0 +1,126 @@
+use crate::errors::{GrimpError, GrimpResult};
+use crate::graph::{
+    ExtendWithDescendants, Graph, ImportDetails, ModuleToken, EMPTY_IMPORT_DETAILS,
+    EMPTY_MODULE_TOKENS, MODULE_NAMES,
+};
+use crate::module_expressions::ModuleExpression;
+use rustc_hash::FxHashSet;
+
+impl Graph {
+    pub fn count_imports(&self) -> usize {
+        self.imports.values().map(|imports| imports.len()).sum()
+    }
+
+    pub fn direct_import_exists(
+        &self,
+        importer: ModuleToken,
+        imported: ModuleToken,
+        as_packages: bool,
+    ) -> GrimpResult<bool> {
+        let mut importer: FxHashSet<_> = importer.into();
+        let mut imported: FxHashSet<_> = imported.into();
+        if as_packages {
+            importer.extend_with_descendants(self);
+            imported.extend_with_descendants(self);
+            if !(&importer & &imported).is_empty() {
+                return Err(GrimpError::SharedDescendants);
+            }
+        }
+
+        let direct_imports = importer
+            .iter()
+            .flat_map(|module| self.imports.get(*module).unwrap().iter().cloned())
+            .collect::<FxHashSet<ModuleToken>>();
+
+        Ok(!(&direct_imports & &imported).is_empty())
+    }
+
+    pub fn modules_directly_imported_by(&self, importer: ModuleToken) -> &FxHashSet<ModuleToken> {
+        self.imports.get(importer).unwrap_or(&EMPTY_MODULE_TOKENS)
+    }
+
+    pub fn modules_that_directly_import(&self, imported: ModuleToken) -> &FxHashSet<ModuleToken> {
+        self.reverse_imports
+            .get(imported)
+            .unwrap_or(&EMPTY_MODULE_TOKENS)
+    }
+
+    pub fn get_import_details(
+        &self,
+        importer: ModuleToken,
+        imported: ModuleToken,
+    ) -> &FxHashSet<ImportDetails> {
+        match self.import_details.get(&(importer, imported)) {
+            Some(import_details) => import_details,
+            None => &EMPTY_IMPORT_DETAILS,
+        }
+    }
+
+    pub fn find_matching_direct_imports(
+        &self,
+        importer_expression: &ModuleExpression,
+        imported_expression: &ModuleExpression,
+    ) -> FxHashSet<(ModuleToken, ModuleToken)> {
+        let interner = MODULE_NAMES.read().unwrap();
+        self.imports
+            .iter()
+            .flat_map(|(importer, imports)| {
+                imports
+                    .iter()
+                    .cloned()
+                    .map(move |imported| (importer, imported))
+            })
+            .filter(|(importer, imported)| {
+                let importer = self.get_module(*importer).unwrap();
+                let importer_name = interner.resolve(importer.interned_name).unwrap();
+                let imported = self.get_module(*imported).unwrap();
+                let imported_name = interner.resolve(imported.interned_name).unwrap();
+                importer_expression.is_match(importer_name)
+                    && imported_expression.is_match(imported_name)
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_find_matching_direct_imports() {
+        let mut graph = Graph::default();
+
+        let _ = graph.get_or_add_module("pkg.animals").token;
+        let dog = graph.get_or_add_module("pkg.animals.dog").token;
+        let cat = graph.get_or_add_module("pkg.animals.cat").token;
+        let _ = graph.get_or_add_module("pkg.food").token;
+        let chicken = graph.get_or_add_module("pkg.food.chicken").token;
+        let fish = graph.get_or_add_module("pkg.food.fish").token;
+        let _ = graph.get_or_add_module("pkg.colors").token;
+        let golden = graph.get_or_add_module("pkg.colors.golden").token;
+        let ginger = graph.get_or_add_module("pkg.colors.ginger").token;
+        let _ = graph.get_or_add_module("pkg.shops").token;
+        let tesco = graph.get_or_add_module("pkg.shops.tesco").token;
+        let coop = graph.get_or_add_module("pkg.shops.coop").token;
+
+        // Should match
+        graph.add_import(dog, chicken);
+        graph.add_import(cat, fish);
+        // Should not match: Imported does not match
+        graph.add_import(dog, golden);
+        graph.add_import(cat, ginger);
+        // Should not match: Importer does not match
+        graph.add_import(tesco, chicken);
+        graph.add_import(coop, fish);
+
+        let importer_expression = "pkg.animals.*".parse().unwrap();
+        let imported_expression = "pkg.food.*".parse().unwrap();
+        let matching_imports =
+            graph.find_matching_direct_imports(&importer_expression, &imported_expression);
+
+        assert_eq!(
+            matching_imports,
+            FxHashSet::from_iter([(dog, chicken), (cat, fish)])
+        );
+    }
+}

{grimp-3.6 → grimp-3.7}/rust/src/graph/graph_manipulation.rs

@@ -1,4 +1,6 @@
-use crate::graph::{Graph, ImportDetails, Module, ModuleIterator, ModuleToken, MODULE_NAMES};
+use crate::graph::{
+    Graph, ImportDetails, Module, ModuleIterator, ModuleToken, IMPORT_LINE_CONTENTS, MODULE_NAMES,
+};
 use rustc_hash::FxHashSet;
 use slotmap::secondary::Entry;
 
@@ -31,7 +33,7 @@ impl Graph {
                 } else {
                     let module = self.modules.insert_with_key(|token| Module {
                         token,
-                        name,
+                        interned_name: name,
                         is_invisible: !ancestor_names.is_empty(),
                         is_squashed: false,
                     });
@@ -116,7 +118,7 @@ impl Graph {
         &mut self,
         importer: ModuleToken,
         imported: ModuleToken,
-        line_number: usize,
+        line_number: u32,
         line_contents: &str,
     ) {
         self.imports
@@ -129,10 +131,14 @@ impl Graph {
             .unwrap()
             .or_default()
             .insert(importer);
-        self.import_details
-            .entry((importer, imported))
-            .or_default()
-            .insert(ImportDetails::new(line_number, line_contents.to_owned()));
+        {
+            let mut interner = IMPORT_LINE_CONTENTS.write().unwrap();
+            let line_contents = interner.get_or_intern(line_contents);
+            self.import_details
+                .entry((importer, imported))
+                .or_default()
+                .insert(ImportDetails::new(line_number, line_contents));
+        }
     }
 
     pub fn remove_import(&mut self, importer: ModuleToken, imported: ModuleToken) {

grimp-3.7/rust/src/graph/hierarchy_queries.rs

@@ -0,0 +1,105 @@
+use crate::graph::{Graph, Module, ModuleIterator, ModuleToken, MODULE_NAMES};
+use crate::module_expressions::ModuleExpression;
+use rustc_hash::FxHashSet;
+
+impl Graph {
+    pub fn get_module_by_name(&self, name: &str) -> Option<&Module> {
+        let interner = MODULE_NAMES.read().unwrap();
+        let name = interner.get(name)?;
+        match self.modules_by_name.get_by_left(&name) {
+            Some(token) => self.get_module(*token),
+            None => None,
+        }
+    }
+
+    pub fn get_module(&self, module: ModuleToken) -> Option<&Module> {
+        self.modules.get(module)
+    }
+
+    // TODO(peter) Guarantee order?
+    pub fn all_modules(&self) -> impl ModuleIterator {
+        self.modules.values()
+    }
+
+    pub fn get_module_parent(&self, module: ModuleToken) -> Option<&Module> {
+        match self.module_parents.get(module) {
+            Some(parent) => parent.map(|parent| self.get_module(parent).unwrap()),
+            None => None,
+        }
+    }
+
+    pub fn get_module_children(&self, module: ModuleToken) -> impl ModuleIterator {
+        let children = match self.module_children.get(module) {
+            Some(children) => children
+                .iter()
+                .map(|child| self.get_module(*child).unwrap())
+                .collect(),
+            None => Vec::new(),
+        };
+        children.into_iter()
+    }
+
+    /// Returns an iterator over the passed modules descendants.
+    ///
+    /// Parent modules will be yielded before their child modules.
+    pub fn get_module_descendants(&self, module: ModuleToken) -> impl ModuleIterator {
+        let mut descendants = self.get_module_children(module).collect::<Vec<_>>();
+        for child in descendants.clone() {
+            descendants.extend(self.get_module_descendants(child.token).collect::<Vec<_>>())
+        }
+        descendants.into_iter()
+    }
+
+    pub fn find_matching_modules(&self, expression: &ModuleExpression) -> impl ModuleIterator {
+        let interner = MODULE_NAMES.read().unwrap();
+        let modules: FxHashSet<_> = self
+            .modules
+            .values()
+            .filter(|m| expression.is_match(interner.resolve(m.interned_name).unwrap()))
+            .collect();
+        modules.into_iter()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::graph::ModuleIterator;
+    use derive_new::new;
+    use parameterized::parameterized;
+
+    #[derive(Debug, new)]
+    struct FindMatchingModulesTestCase<'a> {
+        expression: &'a str,
+        #[new(into)]
+        expected_matching_modules: Vec<&'a str>,
+    }
+
+    #[parameterized(case = {
+        FindMatchingModulesTestCase::new("foo", ["foo"]),
+        FindMatchingModulesTestCase::new("foo.*", ["foo.bar"]),
+        FindMatchingModulesTestCase::new("foo.**", ["foo.bar", "foo.bar.baz"]),
+    })]
+    fn test_find_matching_modules(case: FindMatchingModulesTestCase) {
+        // The test here is just a sense check - we don't need to check again here how all the
+        // different types of module expressions work since that is already tested
+        // thoroughly elsewhere.
+        let mut graph = Graph::default();
+        graph.get_or_add_module("foo");
+        graph.get_or_add_module("foo.bar");
+        graph.get_or_add_module("foo.bar.baz");
+
+        let expression = case.expression.parse().unwrap();
+
+        let matching_modules: FxHashSet<_> =
+            graph.find_matching_modules(&expression).tokens().collect();
+
+        assert_eq!(
+            matching_modules,
+            case.expected_matching_modules
+                .into_iter()
+                .map(|module| graph.get_module_by_name(module).unwrap().token)
+                .collect()
+        );
+    }
+}

{grimp-3.6 → grimp-3.7}/rust/src/graph/import_chain_queries.rs

@@ -1,5 +1,5 @@
 use crate::errors::GrimpResult;
-use crate::graph::pathfinding::{find_reach, find_shortest_path_bidirectional};
+use crate::graph::pathfinding::{find_reach, find_shortest_path};
 use crate::graph::{ExtendWithDescendants, Graph, ModuleToken};
 use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -62,7 +62,7 @@ impl Graph {
         excluded_modules: &FxHashSet<ModuleToken>,
         excluded_imports: &FxHashMap<ModuleToken, FxHashSet<ModuleToken>>,
     ) -> GrimpResult<Option<Vec<ModuleToken>>> {
-        find_shortest_path_bidirectional(
+        find_shortest_path(
             self,
             from_modules,
             to_modules,

{grimp-3.6 → grimp-3.7}/rust/src/graph/mod.rs

@@ -19,6 +19,8 @@ pub(crate) mod pathfinding;
 lazy_static! {
     static ref MODULE_NAMES: RwLock<StringInterner<StringBackend>> =
         RwLock::new(StringInterner::default());
+    static ref IMPORT_LINE_CONTENTS: RwLock<StringInterner<StringBackend>> =
+        RwLock::new(StringInterner::default());
     static ref EMPTY_MODULE_TOKENS: FxHashSet<ModuleToken> = FxHashSet::default();
     static ref EMPTY_IMPORT_DETAILS: FxHashSet<ImportDetails> = FxHashSet::default();
     static ref EMPTY_IMPORTS: FxHashSet<(ModuleToken, ModuleToken)> = FxHashSet::default();
@@ -32,7 +34,7 @@ pub struct Module {
     token: ModuleToken,
 
     #[getset(get_copy = "pub")]
-    name: DefaultSymbol,
+    interned_name: DefaultSymbol,
 
     // Invisible modules exist in the hierarchy but haven't been explicitly added to the graph.
     #[getset(get_copy = "pub")]
@@ -43,9 +45,9 @@ pub struct Module {
 }
 
 impl Module {
-    pub fn name_as_string(&self) -> String {
+    pub fn name(&self) -> String {
         let interner = MODULE_NAMES.read().unwrap();
-        interner.resolve(self.name).unwrap().to_owned()
+        interner.resolve(self.interned_name).unwrap().to_owned()
     }
 }
 
@@ -102,13 +104,13 @@ pub trait ModuleIterator<'a>: Iterator<Item = &'a Module> + Sized {
         self.map(|m| m.token)
     }
 
-    fn names(self) -> impl Iterator<Item = DefaultSymbol> {
-        self.map(|m| m.name)
+    fn interned_names(self) -> impl Iterator<Item = DefaultSymbol> {
+        self.map(|m| m.interned_name)
     }
 
-    fn names_as_strings(self) -> impl Iterator<Item = String> {
+    fn names(self) -> impl Iterator<Item = String> {
         let interner = MODULE_NAMES.read().unwrap();
-        self.map(move |m| interner.resolve(m.name).unwrap().to_owned())
+        self.map(move |m| interner.resolve(m.interned_name).unwrap().to_owned())
     }
 
     fn visible(self) -> impl ModuleIterator<'a> {
@@ -129,9 +131,18 @@ impl<'a, T: Iterator<Item = &'a ModuleToken>> ModuleTokenIterator<'a> for T {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash, new, Getters, CopyGetters)]
 pub struct ImportDetails {
     #[getset(get_copy = "pub")]
-    line_number: usize,
+    line_number: u32,
 
-    #[new(into)]
-    #[getset(get = "pub")]
-    line_contents: String,
+    #[getset(get_copy = "pub")]
+    interned_line_contents: DefaultSymbol,
+}
+
+impl ImportDetails {
+    pub fn line_contents(&self) -> String {
+        let interner = IMPORT_LINE_CONTENTS.read().unwrap();
+        interner
+            .resolve(self.interned_line_contents)
+            .unwrap()
+            .to_owned()
+    }
 }

{grimp-3.6 → grimp-3.7}/rust/src/graph/pathfinding.rs

@@ -28,7 +28,8 @@ pub fn find_reach(
     &seen.into_iter().collect::<FxHashSet<_>>() - from_modules
 }
 
-pub fn find_shortest_path_bidirectional(
+/// Finds the shortest path, via a bidirectional BFS.
+pub fn find_shortest_path(
     graph: &Graph,
     from_modules: &FxHashSet<ModuleToken>,
     to_modules: &FxHashSet<ModuleToken>,