Call scan_for_imports in Rust

This removes all mention of ImportScanner from Python.

Author: seddonym

rust/src/import_scanning.rs

@@ -38,7 +38,7 @@ impl ImportScanner {
     #[allow(unused_variables)]
     #[new]
     #[pyo3(signature = (file_system, found_packages, include_external_packages=false))]
-    fn new(
+    pub fn new(
         py: Python,
         file_system: Bound<'_, PyAny>,
         found_packages: Bound<'_, PyAny>,
@@ -59,7 +59,7 @@ impl ImportScanner {
     /// Statically analyses the given module and returns a set of Modules that
     /// it imports.
     #[pyo3(signature = (module, exclude_type_checking_imports=false))]
-    fn scan_for_imports<'a>(
+    pub fn scan_for_imports<'a>(
         &self,
         py: Python<'a>,
         module: Bound<'_, PyAny>,

rust/src/lib.rs

@@ -27,6 +27,7 @@ use std::collections::HashSet;
 #[pymodule]
 fn _rustgrimp(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(parse_imported_objects_from_code))?;
+    m.add_wrapped(wrap_pyfunction!(scan_for_imports))?;
     m.add_class::<GraphWrapper>()?;
     m.add_class::<PyRealBasicFileSystem>()?;
     m.add_class::<PyFakeBasicFileSystem>()?;
@@ -41,6 +42,35 @@ fn _rustgrimp(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     Ok(())
 }
 
+#[pyfunction]
+fn scan_for_imports<'py,>(
+    py: Python<'py>,
+    module_files: Vec<Bound<'py, PyAny>>,
+    found_packages: Bound<'py, PyAny>,
+    include_external_packages: bool,
+    exclude_type_checking_imports: bool,
+    file_system: Bound<'py, PyAny>,
+) -> PyResult<Bound<'py, PyDict>>{
+    let scanner = ImportScanner::new(
+        py,
+        file_system,
+        found_packages,
+        include_external_packages,
+    )?;
+    
+    let dict = PyDict::new(py);
+    for module_file in module_files {
+        let py_module_instance = module_file.getattr("module").unwrap();
+        let imports = scanner.scan_for_imports(
+            py,
+            py_module_instance,
+            exclude_type_checking_imports,
+        )?;
+        dict.set_item(module_file, imports).unwrap();
+    }
+    Ok(dict)
+}
+
 #[pyfunction]
 fn parse_imported_objects_from_code<'py>(
     py: Python<'py>,

src/grimp/application/ports/filesystem.py

@@ -93,11 +93,11 @@ def convert_to_basic(self) -> BasicFileSystem:
 
 class BasicFileSystem(Protocol):
     """
-    A more limited file system, used by the ImportScanner.
+    A more limited file system, used by the Rust-based scan_for_imports function.
 
     Having two different file system APIs is an interim approach, allowing us to
-    implement BasicFileSystem in Rust, for use with the ImportScanner, without needing
-    to implement the full range of methods used by other parts of Grimp.
+    implement BasicFileSystem in Rust without needing to implement the full range
+    of methods used by other parts of Grimp.
 
     Eventually we'll move the full implementation to Rust, and have a single
     FileSystem interface.

src/grimp/application/scanning.py

@@ -10,7 +10,6 @@
 from grimp.application.ports.filesystem import AbstractFileSystem
 from grimp.application.ports.modulefinder import ModuleFile, FoundPackage
 
-ImportScanner = rust.ImportScanner
 
 # Calling code can set this environment variable if it wants to tune when to switch to
 # multiprocessing, or set it to a large number to disable it altogether.
@@ -72,19 +71,15 @@ def _scan_chunk(
 ) -> Dict[ModuleFile, Set[DirectImport]]:
     file_system: AbstractFileSystem = settings.FILE_SYSTEM
     basic_file_system = file_system.convert_to_basic()
-    import_scanner = ImportScanner(
-        file_system=basic_file_system,
+    return rust.scan_for_imports(
+        module_files=chunk,
         found_packages=found_packages,
         # Ensure that the passed exclude_type_checking_imports is definitely a boolean,
         # otherwise the Rust class will error.
         include_external_packages=bool(include_external_packages),
+        exclude_type_checking_imports=exclude_type_checking_imports,
+        file_system=basic_file_system,
     )
-    return {
-        module_file: import_scanner.scan_for_imports(
-            module_file.module, exclude_type_checking_imports=exclude_type_checking_imports
-        )
-        for module_file in chunk
-    }
 
 
 def _scan_chunks(