firehot 0.3.4__tar.gz → 0.4.1.dev1__tar.gz

{firehot-0.3.4 → firehot-0.4.1.dev1}/.github/workflows/ci-build.yml

@@ -87,6 +87,7 @@ jobs:
       matrix:
         os: [ubuntu-latest, macos-latest]
         python-version: ['3.10', '3.11', '3.12', '3.13']
+        target: [aarch64, x86_64]
     
     steps:
       - uses: actions/checkout@v3
@@ -103,9 +104,6 @@ jobs:
           toolchain: stable
           override: true
       
-      - name: Install maturin
-        run: pip install maturin
-
       - name: Update version
         if: startsWith(github.ref, 'refs/tags/v')
         shell: bash
@@ -113,13 +111,23 @@ jobs:
           pip install packaging toml
           python .github/scripts/update_version.py ${{ github.ref_name }}
 
-      - name: Build wheels
-        run: maturin build --release --strip --out dist
+      - name: build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: -vv --release --out dist --interpreter ${{ matrix.python-version }}
+          rust-toolchain: stable
+          docker-options: -e CI -e CI_TARGET=${{ matrix.target }}
+          # Already defaults to build, but we make explicit here. Any arguments should
+          # be added to args above and not here - otherwise we will affect the switch()
+          # condition handling of maturin-action.
+          command: build
       
       - name: Upload wheels
         uses: actions/upload-artifact@v4
         with:
-          name: wheels-${{ matrix.os }}-py${{ matrix.python-version }}
+          name: wheels-${{ matrix.os }}-py${{ matrix.python-version }}-${{ matrix.target }}
           path: dist/*.whl
 
   # Collate all wheels for PyPI upload

{firehot-0.3.4 → firehot-0.4.1.dev1}/Cargo.lock

@@ -217,7 +217,7 @@ checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
 name = "firehot"
-version = "0.3.4"
+version = "0.4.1-dev1"
 dependencies = [
  "anstream",
  "anyhow",

{firehot-0.3.4 → firehot-0.4.1.dev1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "firehot"
-version = "0.3.4"
+version = "0.4.1-dev1"
 edition = "2021"
 
 [lib]

{firehot-0.3.4 → firehot-0.4.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firehot
-Version: 0.3.4
+Version: 0.4.1.dev1
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License

{firehot-0.3.4 → firehot-0.4.1.dev1}/firehot/__tests__/test_context.py

@@ -1,7 +1,7 @@
 import importlib
 from pathlib import Path
 
-from firehot.context import resolve_package_metadata
+from firehot.context import isolate_imports, resolve_package_metadata
 
 
 def test_resolve_package_metadata(sample_package):
@@ -29,3 +29,19 @@ def test_resolve_package_metadata(sample_package):
 
     # Check that the directory name matches the package name
     assert resolved_path.name == sample_package
+
+
+def test_isolate_imports(sample_package):
+    """
+    Test that isolate_imports correctly creates an isolated environment and accepts ignored_modules.
+    """
+    # Test basic functionality without ignored modules
+    with isolate_imports(sample_package) as env:
+        assert env.runner_id is not None, "Expected runner_id to be set"
+
+    # Test with ignored modules
+    ignored = ["numpy", "pandas"]
+    with isolate_imports(sample_package, ignored_modules=ignored) as env:
+        assert env.runner_id is not None, "Expected runner_id to be set"
+        # The runner_id should be different from the previous one
+        assert isinstance(env.runner_id, str), "Expected runner_id to be a string"

{firehot-0.3.4 → firehot-0.4.1.dev1}/firehot/context.py

@@ -42,18 +42,21 @@ def resolve_package_metadata(package: str) -> tuple[str, str]:
 
 
 @contextmanager
-def isolate_imports(package: str):
+def isolate_imports(package: str, *, ignored_modules: list[str] | None = None):
     """
     Context manager that isolates imports for the given package path.
 
     :param package: Package to isolate imports. This must be importable from the current
                     virtual environment
+    :param ignored_modules: Optional list of module names to ignore during hot reloading.
+                          Changes to these modules will not trigger reloads.
     :yields: An Environment object that can be used to execute code in the isolated environment
+
     """
     package_path, package_name = resolve_package_metadata(package)
     runner_id: str | None = None
     try:
-        runner_id = start_import_runner_rs(package_name, package_path)
+        runner_id = start_import_runner_rs(package_name, package_path, ignored_modules)
         yield Environment(runner_id)
     finally:
         if runner_id:

{firehot-0.3.4 → firehot-0.4.1.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "firehot"
-version = "0.3.4"
+version = "0.4.1.dev1"
 description = "Wicked fast hot reloading"
 readme = "README.md"
 requires-python = ">=3.10"

{firehot-0.3.4 → firehot-0.4.1.dev1}/src/ast.rs

@@ -44,11 +44,17 @@ pub struct ProjectAstManager {
     package_name: String,
     /// The root path of the project
     project_path: String,
+    /// Set of modules to ignore when determining third-party imports
+    ignored_modules: HashSet<String>,
 }
 
 impl ProjectAstManager {
     /// Create a new ProjectAstManager for the given project path
-    pub fn new(project_name: &str, project_path: &str) -> Self {
+    pub fn new(
+        project_name: &str,
+        project_path: &str,
+        ignored_modules: Option<HashSet<String>>,
+    ) -> Self {
         debug!(
             "Creating new ProjectAstManager for {} at {}",
             project_name, project_path
@@ -58,6 +64,7 @@ impl ProjectAstManager {
             file_imports: HashMap::new(),
             package_name: project_name.to_string(),
             project_path: project_path.to_string(),
+            ignored_modules: ignored_modules.unwrap_or_default(),
         }
     }
 
@@ -226,6 +233,11 @@ impl ProjectAstManager {
         trace!("Checking if import is third party: {:?}", imp);
         trace!("Package name: {}", self.package_name);
 
+        // If the module is in the ignored list, it's not considered third-party
+        if self.ignored_modules.contains(&imp.module) {
+            return false;
+        }
+
         let is_third_party = !imp.is_relative && !imp.module.starts_with(&self.package_name);
 
         trace!("Is third party: {}", is_third_party);
@@ -350,7 +362,7 @@ mod tests {
 
     #[test]
     fn test_project_ast_manager_initialization() {
-        let manager = ProjectAstManager::new("test_package", "/test/path");
+        let manager = ProjectAstManager::new("test_package", "/test/path", None);
         assert_eq!(manager.get_project_path(), "/test/path");
         assert_eq!(manager.get_package_name(), "test_package");
     }
@@ -360,7 +372,8 @@ mod tests {
         let temp_dir = TempDir::new().unwrap();
         let file_path = create_temp_py_file(&temp_dir, "test.py", "print('hello')");
 
-        let manager = ProjectAstManager::new("test_package", temp_dir.path().to_str().unwrap());
+        let manager =
+            ProjectAstManager::new("test_package", temp_dir.path().to_str().unwrap(), None);
         let hash_result = manager.calculate_file_hash(file_path.to_str().unwrap());
 
         assert!(hash_result.is_ok());
@@ -573,7 +586,7 @@ def function():
 
     #[test]
     fn test_is_third_party_import() {
-        let manager = ProjectAstManager::new("my_package", "/test/path");
+        let manager = ProjectAstManager::new("my_package", "/test/path", None);
 
         // First-party absolute import (starts with package name)
         let first_party = ImportInfo {
@@ -612,7 +625,8 @@ def function():
         let python_code = "import os\nimport sys";
         let file_path = create_temp_py_file(&temp_dir, "test_file.py", python_code);
 
-        let mut manager = ProjectAstManager::new("test_package", temp_dir.path().to_str().unwrap());
+        let mut manager =
+            ProjectAstManager::new("test_package", temp_dir.path().to_str().unwrap(), None);
         let imports_result = manager.process_py_file(file_path.to_str().unwrap());
 
         assert!(imports_result.is_ok());
@@ -630,7 +644,8 @@ def function():
         let file_path = create_temp_py_file(&temp_dir, "test_cache.py", python_code);
         let path_str = file_path.to_str().unwrap();
 
-        let mut manager = ProjectAstManager::new("test_package", temp_dir.path().to_str().unwrap());
+        let mut manager =
+            ProjectAstManager::new("test_package", temp_dir.path().to_str().unwrap(), None);
 
         // First call should parse the file
         let _ = manager.process_py_file(path_str).unwrap();
@@ -669,7 +684,8 @@ def function():
         let file1_path = create_temp_py_file(&temp_dir, "file1.py", "import os\nimport requests");
         let _file2_path = create_temp_py_file(&temp_dir, "file2.py", "import sys\nimport flask");
 
-        let mut manager = ProjectAstManager::new("testpkg", temp_dir.path().to_str().unwrap());
+        let mut manager =
+            ProjectAstManager::new("testpkg", temp_dir.path().to_str().unwrap(), None);
 
         // Initial processing
         let initial_imports = manager.process_all_py_files().unwrap();
@@ -700,4 +716,95 @@ def function():
         assert!(!removed.is_empty());
         assert!(removed.contains("requests"));
     }
+
+    #[test]
+    fn test_ignored_modules() {
+        let temp_dir = TempDir::new().unwrap();
+
+        // Create a Python file with various imports
+        let python_code = r#"
+import os
+import sys
+import requests
+from pandas import DataFrame
+from my_package.utils import helper
+from . import local_module
+        "#;
+        create_temp_py_file(&temp_dir, "test_imports.py", python_code);
+
+        // Create a manager with ignored modules
+        let mut ignored_modules = HashSet::new();
+        ignored_modules.insert("pandas".to_string());
+        ignored_modules.insert("requests".to_string());
+
+        let mut manager = ProjectAstManager::new(
+            "my_package",
+            temp_dir.path().to_str().unwrap(),
+            Some(ignored_modules),
+        );
+
+        // Process all files and get third-party imports
+        let third_party_imports = manager.process_all_py_files().unwrap();
+
+        // Verify that ignored modules are not included in third-party imports
+        assert!(
+            !third_party_imports.contains("pandas"),
+            "pandas should be ignored"
+        );
+        assert!(
+            !third_party_imports.contains("requests"),
+            "requests should be ignored"
+        );
+
+        // But other third-party modules should be included
+        assert!(third_party_imports.contains("os"), "os should be included");
+        assert!(
+            third_party_imports.contains("sys"),
+            "sys should be included"
+        );
+
+        // First-party imports should still be excluded
+        assert!(
+            !third_party_imports.contains("my_package.utils"),
+            "my_package.utils should not be included"
+        );
+        assert!(
+            !third_party_imports.contains("local_module"),
+            "local_module should not be included"
+        );
+
+        // Now test with no ignored modules
+        let mut manager_no_ignore =
+            ProjectAstManager::new("my_package", temp_dir.path().to_str().unwrap(), None);
+
+        let all_third_party_imports = manager_no_ignore.process_all_py_files().unwrap();
+
+        // Without ignore list, all third-party modules should be included
+        assert!(
+            all_third_party_imports.contains("pandas"),
+            "pandas should be included when not ignored"
+        );
+        assert!(
+            all_third_party_imports.contains("requests"),
+            "requests should be included when not ignored"
+        );
+        assert!(
+            all_third_party_imports.contains("os"),
+            "os should be included"
+        );
+        assert!(
+            all_third_party_imports.contains("sys"),
+            "sys should be included"
+        );
+
+        // First-party imports should still be excluded
+        assert!(
+            !all_third_party_imports.contains("my_package.utils"),
+            "my_package.utils should not be included"
+        );
+        assert!(
+            !all_third_party_imports.contains("local_module"),
+            "local_module should not be included"
+        );
+    }
 }

{firehot-0.3.4 → firehot-0.4.1.dev1}/src/environment.rs

@@ -30,9 +30,13 @@ pub struct Environment {
 }
 
 impl Environment {
-    pub fn new(project_name: &str, project_path: &str) -> Self {
+    pub fn new(
+        project_name: &str,
+        project_path: &str,
+        ignored_modules: Option<HashSet<String>>,
+    ) -> Self {
         // Create a new AST manager for this project
-        let ast_manager = ProjectAstManager::new(project_name, project_path);
+        let ast_manager = ProjectAstManager::new(project_name, project_path, ignored_modules);
         info!("Created AST manager for project: {}", project_name);
 
         Self {
@@ -45,9 +49,13 @@ impl Environment {
     }
 
     /// Create a new Environment in test mode (buffers output instead of printing)
-    pub fn new_for_test(project_name: &str, project_path: &str) -> Self {
+    pub fn new_for_test(
+        project_name: &str,
+        project_path: &str,
+        ignored_modules: Option<HashSet<String>>,
+    ) -> Self {
         // Create a new AST manager for this project
-        let ast_manager = ProjectAstManager::new(project_name, project_path);
+        let ast_manager = ProjectAstManager::new(project_name, project_path, ignored_modules);
         info!("Created AST manager for project: {}", project_name);
 
         Self {
@@ -647,7 +655,7 @@ mod tests {
         // Create a simple Python project
         create_temp_py_file(&temp_dir, "main.py", "print('Hello, world!')");
 
-        let mut runner = Environment::new("test_package", dir_path);
+        let mut runner = Environment::new("test_package", dir_path, None);
         assert_eq!(runner.ast_manager.get_project_path(), dir_path);
 
         // Boot the environment before checking it
@@ -668,7 +676,7 @@ mod tests {
         // Create a simple Python project with initial imports
         create_temp_py_file(&temp_dir, "main.py", "import os\nimport sys");
 
-        let mut runner = Environment::new("test_package", dir_path);
+        let mut runner = Environment::new("test_package", dir_path, None);
 
         // Boot the environment before accessing it
         runner.boot_main().expect("Failed to boot main environment");
@@ -750,7 +758,7 @@ def main():
             crate::test_utils::harness::prepare_script_for_isolation(python_script, "main")
                 .expect("Failed to prepare script for isolation");
 
-        let mut runner = Environment::new("test_package", &python_env.container_path);
+        let mut runner = Environment::new("test_package", &python_env.container_path, None);
 
         // Boot the environment before accessing it
         runner.boot_main().expect("Failed to boot main environment");
@@ -800,7 +808,7 @@ def main():
         let temp_dir = TempDir::new().unwrap();
         let dir_path = temp_dir.path().to_str().unwrap();
 
-        let mut runner = Environment::new("test_package", dir_path);
+        let mut runner = Environment::new("test_package", dir_path, None);
 
         // Boot the environment before accessing it
         runner.boot_main().expect("Failed to boot main environment");
@@ -885,7 +893,7 @@ def main():
         let temp_dir = TempDir::new().unwrap();
         let dir_path = temp_dir.path().to_str().unwrap();
 
-        let mut runner = Environment::new("test_package", dir_path);
+        let mut runner = Environment::new("test_package", dir_path, None);
 
         // Boot the environment before stopping it
         runner.boot_main().expect("Failed to boot main environment");
@@ -921,7 +929,7 @@ def main():
             crate::test_utils::harness::prepare_script_for_isolation(python_script, "main")?;
 
         // Create and boot the Environment
-        let mut runner = Environment::new("test_package", dir_path);
+        let mut runner = Environment::new("test_package", dir_path, None);
         runner.boot_main()?;
 
         // Execute the script in isolation - this should not fail at this point
@@ -980,7 +988,7 @@ def main():
                 .expect("Failed to prepare long-running script for isolation");
 
         // Create and boot environment
-        let mut runner = Environment::new("test_package", &python_env.container_path);
+        let mut runner = Environment::new("test_package", &python_env.container_path, None);
         runner.boot_main().expect("Failed to boot main environment");
 
         // Execute the long-running function

{firehot-0.3.4 → firehot-0.4.1.dev1}/src/layer.rs

@@ -648,7 +648,7 @@ def main():
             crate::test_utils::harness::prepare_script_for_isolation(python_script, "main")?;
 
         // Create and boot the Environment
-        let mut runner = Environment::new_for_test("test_package", dir_path);
+        let mut runner = Environment::new_for_test("test_package", dir_path, None);
         runner.boot_main()?;
 
         // Execute the script in isolation
@@ -725,7 +725,7 @@ def main():
             crate::test_utils::harness::prepare_script_for_isolation(python_script, "main")?;
 
         // Create and boot the Environment
-        let mut runner = Environment::new_for_test("test_package", dir_path);
+        let mut runner = Environment::new_for_test("test_package", dir_path, None);
         runner.boot_main()?;
 
         // Execute the script in isolation

{firehot-0.3.4 → firehot-0.4.1.dev1}/src/lib.rs

@@ -7,6 +7,7 @@ use std::{collections::HashMap, time::Instant};
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
+use std::collections::HashSet;
 use std::sync::Mutex;
 use uuid::Uuid;
 
@@ -86,7 +87,12 @@ fn firehot(_py: Python, m: &PyModule) -> PyResult<()> {
 
 /// Initialize and start the import runner, returning a unique identifier
 #[pyfunction]
-fn start_import_runner(_py: Python, project_name: &str, package_path: &str) -> PyResult<String> {
+fn start_import_runner(
+    _py: Python,
+    project_name: &str,
+    package_path: &str,
+    ignored_modules: Option<Vec<String>>,
+) -> PyResult<String> {
     // Generate a unique ID for this runner
     let env_id = Uuid::new_v4().to_string();
 
@@ -98,9 +104,13 @@ fn start_import_runner(_py: Python, project_name: &str, package_path: &str) -> P
         project_name.cyan().bold()
     );
 
+    // Convert ignored_modules from Vec to HashSet if provided
+    let ignored_modules_set =
+        ignored_modules.map(|modules| modules.into_iter().collect::<HashSet<String>>());
+
     // Create the runner object
     info!("Creating environment with ID: {}", env_id);
-    let mut runner = environment::Environment::new(project_name, package_path);
+    let mut runner = environment::Environment::new(project_name, package_path, ignored_modules_set);
 
     runner.boot_main().map_err(|e| {
         error!("Failed to boot main: {}", e);

{firehot-0.3.4 → firehot-0.4.1.dev1}/src/test_utils/harness.rs

@@ -253,7 +253,7 @@ def main():
         let (pickled_data, python_env) = prepare_script_for_isolation(python_script, "main")?;
 
         // Create a mock Environment
-        let mut runner = Environment::new("test_package", &python_env.container_path);
+        let mut runner = Environment::new("test_package", &python_env.container_path, None);
 
         // Boot the environment
         runner.boot_main()?;