firehot 0.4.1__tar.gz → 0.4.2.dev1__tar.gz

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

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

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

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

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

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

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

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

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

@@ -223,7 +223,7 @@ impl ProjectAstManager {
         let mut hasher = Sha256::new();
         hasher.update(&content);
         let hash = hasher.finalize();
-        let hash_str = format!("{:x}", hash);
+        let hash_str = format!("{hash:x}");
         trace!("Calculated hash for {}: {}", file_path, hash_str);
         Ok(hash_str)
     }
@@ -404,13 +404,13 @@ mod tests {
         assert_eq!(imports.len(), 2);
         assert_eq!(imports[0].module, "os");
         assert_eq!(imports[0].names, vec!["os"]);
-        assert_eq!(imports[0].is_relative, false);
-        assert_eq!(imports[0].is_from_import, false);
+        assert!(!imports[0].is_relative);
+        assert!(!imports[0].is_from_import);
 
         assert_eq!(imports[1].module, "sys");
         assert_eq!(imports[1].names, vec!["sys"]);
-        assert_eq!(imports[1].is_relative, false);
-        assert_eq!(imports[1].is_from_import, false);
+        assert!(!imports[1].is_relative);
+        assert!(!imports[1].is_from_import);
     }
 
     #[test]
@@ -432,13 +432,13 @@ mod tests {
         assert_eq!(imports.len(), 2);
         assert_eq!(imports[0].module, "os");
         assert_eq!(imports[0].names, vec!["path"]);
-        assert_eq!(imports[0].is_relative, false);
-        assert_eq!(imports[0].is_from_import, true);
+        assert!(!imports[0].is_relative);
+        assert!(imports[0].is_from_import);
 
         assert_eq!(imports[1].module, "sys");
         assert_eq!(imports[1].names, vec!["argv", "version"]);
-        assert_eq!(imports[1].is_relative, false);
-        assert_eq!(imports[1].is_from_import, true);
+        assert!(!imports[1].is_relative);
+        assert!(imports[1].is_from_import);
     }
 
     #[test]
@@ -460,13 +460,13 @@ mod tests {
         assert_eq!(imports.len(), 2);
         assert_eq!(imports[0].module, "os");
         assert_eq!(imports[0].names, vec!["os"]);
-        assert_eq!(imports[0].is_relative, false);
-        assert_eq!(imports[0].is_from_import, false);
+        assert!(!imports[0].is_relative);
+        assert!(!imports[0].is_from_import);
 
         assert_eq!(imports[1].module, "sys");
         assert_eq!(imports[1].names, vec!["argv"]);
-        assert_eq!(imports[1].is_relative, false);
-        assert_eq!(imports[1].is_from_import, true);
+        assert!(!imports[1].is_relative);
+        assert!(imports[1].is_from_import);
     }
 
     #[test]
@@ -486,7 +486,7 @@ mod tests {
         let imports = collect_imports(stmts);
 
         // Debugging to understand the actual structure
-        println!("Relative imports found: {:#?}", imports);
+        println!("Relative imports found: {imports:#?}");
 
         // For now, just check that we find something, we'll refine this test
         // after seeing the actual output structure
@@ -494,8 +494,8 @@ mod tests {
 
         // All these should be relative from imports
         for import in &imports {
-            assert_eq!(import.is_from_import, true);
-            assert_eq!(import.is_relative, true);
+            assert!(import.is_from_import);
+            assert!(import.is_relative);
         }
     }
 
@@ -574,14 +574,14 @@ def function():
         // First import: "import time"
         assert_eq!(imports[0].module, "time");
         assert_eq!(imports[0].names, vec!["time"]);
-        assert_eq!(imports[0].is_relative, false);
-        assert_eq!(imports[0].is_from_import, false); // This is a simple import
+        assert!(!imports[0].is_relative);
+        assert!(!imports[0].is_from_import); // This is a simple import
 
         // Second import: "from time import time as time_func"
         assert_eq!(imports[1].module, "time");
         assert_eq!(imports[1].names, vec!["time"]); // Should contain the original name, not the alias
-        assert_eq!(imports[1].is_relative, false);
-        assert_eq!(imports[1].is_from_import, true); // This is a from import
+        assert!(!imports[1].is_relative);
+        assert!(imports[1].is_from_import); // This is a from import
     }
 
     #[test]
@@ -689,7 +689,7 @@ def function():
 
         // Initial processing
         let initial_imports = manager.process_all_py_files().unwrap();
-        println!("Initial imports found: {:#?}", initial_imports);
+        println!("Initial imports found: {initial_imports:#?}");
 
         // Verify we have the expected number of third-party imports
         // os, requests, sys, flask should all be considered third-party
@@ -707,8 +707,8 @@ def function():
 
         // Compute delta - should detect the changes
         let (added, removed) = manager.compute_import_delta().unwrap();
-        println!("Added imports: {:#?}", added);
-        println!("Removed imports: {:#?}", removed);
+        println!("Added imports: {added:#?}");
+        println!("Removed imports: {removed:#?}");
 
         assert!(!added.is_empty());
         assert!(added.contains("pandas"));

{firehot-0.4.1 → firehot-0.4.2.dev1}/src/async_resolve.rs

@@ -76,7 +76,7 @@ impl<T: Clone> AsyncResolve<T> {
             let value_lock_result = self.value.lock();
 
             if let Err(e) = &value_lock_result {
-                let err_msg = format!("Failed to lock value mutex: {:?}", e);
+                let err_msg = format!("Failed to lock value mutex: {e:?}");
                 warn!("{}", err_msg);
                 return Err(err_msg);
             }
@@ -98,7 +98,7 @@ impl<T: Clone> AsyncResolve<T> {
         let completion_lock_result = mutex.lock();
 
         if let Err(e) = &completion_lock_result {
-            let err_msg = format!("Failed to lock completion mutex: {:?}", e);
+            let err_msg = format!("Failed to lock completion mutex: {e:?}");
             warn!("{}", err_msg);
             return Err(err_msg);
         }
@@ -112,7 +112,7 @@ impl<T: Clone> AsyncResolve<T> {
             let wait_result = condvar.wait(completed);
 
             if let Err(e) = &wait_result {
-                let err_msg = format!("Failed to wait on condvar: {:?}", e);
+                let err_msg = format!("Failed to wait on condvar: {e:?}");
                 warn!("{}", err_msg);
                 return Err(err_msg);
             }
@@ -133,7 +133,7 @@ impl<T: Clone> AsyncResolve<T> {
         let value_lock_result = self.value.lock();
 
         if let Err(e) = &value_lock_result {
-            let err_msg = format!("Failed to lock value mutex after wait: {:?}", e);
+            let err_msg = format!("Failed to lock value mutex after wait: {e:?}");
             warn!("{}", err_msg);
             return Err(err_msg);
         }

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

@@ -10,7 +10,6 @@ use std::sync::{Arc, Mutex};
 use std::time::Instant;
 
 use libc;
-use std::io::BufRead;
 use uuid::Uuid;
 
 use crate::ast::ProjectAstManager;
@@ -98,7 +97,7 @@ impl Environment {
         let third_party_modules = self
             .ast_manager
             .process_all_py_files()
-            .map_err(|e| format!("Failed to process Python files: {}", e))?;
+            .map_err(|e| format!("Failed to process Python files: {e}"))?;
 
         let start_time = Instant::now();
 
@@ -108,7 +107,7 @@ impl Environment {
             third_party_modules.len()
         );
         let mut child = spawn_python_loader(&third_party_modules)
-            .map_err(|e| format!("Failed to spawn Python loader: {}", e))?;
+            .map_err(|e| format!("Failed to spawn Python loader: {e}"))?;
 
         let stdin = child
             .stdin
@@ -126,54 +125,26 @@ impl Environment {
             .take()
             .ok_or_else(|| "Failed to capture stderr for python process".to_string())?;
 
-        let reader = BufReader::new(stdout);
-        let mut lines_iter = reader.lines();
-
-        // Create a stderr reader
+        // Create BufReaders for the Layer constructor
+        let stdout_reader = BufReader::new(stdout);
         let stderr_reader = BufReader::new(stderr);
-        let stderr_lines_iter = stderr_reader.lines();
-
-        // Wait for the ImportComplete message
-        info!("Waiting for import completion...");
-        let mut imports_loaded = false;
-        for line in &mut lines_iter {
-            let line = line.map_err(|e| format!("Failed to read line: {}", e))?;
-
-            // Parse the line as a message
-            if let Ok(message) = serde_json::from_str::<Message>(&line) {
-                match message {
-                    Message::ImportComplete(_) => {
-                        info!("Imports loaded successfully");
-                        imports_loaded = true;
-                        break;
-                    }
-                    Message::ImportError(error) => {
-                        error!(
-                            "Import error: {}: {}",
-                            error.error,
-                            error.traceback.clone().unwrap_or_default()
-                        );
-                        return Err(format!(
-                            "Import error: {}: {}",
-                            error.error,
-                            error.traceback.unwrap_or_default()
-                        ));
-                    }
-                    _ => {
-                        // Log other message types for debugging
-                        debug!("Received message: {}", line);
-                    }
-                }
-            } else {
-                // If we can't parse it as a message, log it
-                debug!("Non-message output: {}", line);
-            }
-        }
 
-        if !imports_loaded {
-            error!("Python loader did not report successful imports");
-            return Err("Python loader did not report successful imports".to_string());
-        }
+        // Create the Layer with UTF-8 lossy readers
+        let mut layer = if self.test_mode {
+            // Use the test mode constructor
+            Layer::new_for_test(child, stdin, stdout_reader, stderr_reader)
+        } else {
+            // Use the standard constructor
+            Layer::new(child, stdin, stdout_reader, stderr_reader)
+        };
+
+        // Start the monitor thread immediately
+        layer.start_monitor_thread();
+
+        // For now, we'll assume imports are loaded successfully
+        // The Layer will handle any import errors through its normal monitoring
+        info!("Layer created and monitor thread started");
+        let _imports_loaded = true;
 
         // Calculate total setup time and log completion
         let elapsed = start_time.elapsed();
@@ -198,16 +169,7 @@ impl Environment {
             format!("with ID: {}", self.id).white().bold()
         );
 
-        let mut layer = if self.test_mode {
-            // Use the test mode constructor
-            Layer::new_for_test(child, stdin, lines_iter, stderr_lines_iter)
-        } else {
-            // Use the standard constructor
-            Layer::new(child, stdin, lines_iter, stderr_lines_iter)
-        };
-
-        // Start the monitor thread
-        layer.start_monitor_thread();
+        // Layer creation and monitoring setup moved earlier
 
         // Store the layer in the environment
         self.layer = Some(Arc::new(Mutex::new(layer)));
@@ -229,7 +191,7 @@ impl Environment {
 
         let env_guard = layer
             .lock()
-            .map_err(|e| format!("Failed to lock environment mutex: {}", e))?;
+            .map_err(|e| format!("Failed to lock environment mutex: {e}"))?;
 
         // First, stop all child processes
         info!("Stopping all child processes before terminating main process");
@@ -237,7 +199,7 @@ impl Environment {
             let forked_processes = env_guard
                 .forked_processes
                 .lock()
-                .map_err(|e| format!("Failed to lock forked processes: {}", e))?;
+                .map_err(|e| format!("Failed to lock forked processes: {e}"))?;
 
             // Create a clone of all keys to avoid borrowing issues
             forked_processes.keys().cloned().collect::<Vec<String>>()
@@ -257,16 +219,16 @@ impl Environment {
         // Re-acquire the env_guard
         let mut env_guard = layer
             .lock()
-            .map_err(|e| format!("Failed to lock environment mutex: {}", e))?;
+            .map_err(|e| format!("Failed to lock environment mutex: {e}"))?;
 
         // Now send ExitRequest to the parent process to allow it to clean up gracefully
         info!("Sending ExitRequest to parent process");
         let exit_request = ExitRequest::new();
         let exit_json = serde_json::to_string(&Message::ExitRequest(exit_request))
-            .map_err(|e| format!("Failed to serialize exit request: {}", e))?;
+            .map_err(|e| format!("Failed to serialize exit request: {e}"))?;
 
         // Send the message to the parent process
-        if let Err(e) = writeln!(env_guard.stdin, "{}", exit_json) {
+        if let Err(e) = writeln!(env_guard.stdin, "{exit_json}") {
             warn!("Failed to write exit request to parent stdin: {}", e);
         } else if let Err(e) = env_guard.stdin.flush() {
             warn!("Failed to flush parent stdin: {}", e);
@@ -298,21 +260,21 @@ impl Environment {
         let mut forked_processes = env_guard
             .forked_processes
             .lock()
-            .map_err(|e| format!("Failed to lock forked processes: {}", e))?;
+            .map_err(|e| format!("Failed to lock forked processes: {e}"))?;
         forked_processes.clear();
         drop(forked_processes);
 
         let mut fork_resolvers = env_guard
             .fork_resolvers
             .lock()
-            .map_err(|e| format!("Failed to lock fork resolvers: {}", e))?;
+            .map_err(|e| format!("Failed to lock fork resolvers: {e}"))?;
         fork_resolvers.clear();
         drop(fork_resolvers);
 
         let mut completion_resolvers = env_guard
             .completion_resolvers
             .lock()
-            .map_err(|e| format!("Failed to lock completion resolvers: {}", e))?;
+            .map_err(|e| format!("Failed to lock completion resolvers: {e}"))?;
         completion_resolvers.clear();
         drop(completion_resolvers);
 
@@ -332,7 +294,7 @@ impl Environment {
         let (added, removed) = self
             .ast_manager
             .compute_import_delta()
-            .map_err(|e| format!("Failed to compute import delta: {}", e))?;
+            .map_err(|e| format!("Failed to compute import delta: {e}"))?;
 
         // Check if imports have changed
         if added.is_empty() && removed.is_empty() {
@@ -350,13 +312,13 @@ impl Environment {
             let forked_processes = {
                 let env_guard = env
                     .lock()
-                    .map_err(|e| format!("Failed to lock layer mutex: {}", e))?;
+                    .map_err(|e| format!("Failed to lock layer mutex: {e}"))?;
 
                 // Get the forked processes mutex
                 let forked_processes_guard = env_guard
                     .forked_processes
                     .lock()
-                    .map_err(|e| format!("Failed to lock forked processes: {}", e))?;
+                    .map_err(|e| format!("Failed to lock forked processes: {e}"))?;
 
                 // Create a copy of the process UUIDs
                 forked_processes_guard
@@ -402,14 +364,14 @@ impl Environment {
         // Send the code to the forked process
         let mut env_guard = environment
             .lock()
-            .map_err(|e| format!("Failed to lock environment mutex: {}", e))?;
+            .map_err(|e| format!("Failed to lock environment mutex: {e}"))?;
 
         // Create async resolvers for both fork status and completion
         let fork_resolver = AsyncResolve::new();
         let mut fork_resolvers = env_guard
             .fork_resolvers
             .lock()
-            .map_err(|e| format!("Failed to lock fork resolvers: {}", e))?;
+            .map_err(|e| format!("Failed to lock fork resolvers: {e}"))?;
         fork_resolvers.insert(process_uuid.clone(), fork_resolver.clone());
         drop(fork_resolvers);
 
@@ -417,16 +379,15 @@ impl Environment {
         let mut completion_resolvers = env_guard
             .completion_resolvers
             .lock()
-            .map_err(|e| format!("Failed to lock completion resolvers: {}", e))?;
+            .map_err(|e| format!("Failed to lock completion resolvers: {e}"))?;
         completion_resolvers.insert(process_uuid.clone(), completion_resolver.clone());
         drop(completion_resolvers);
 
         let exec_code = format!(
             r#"
-pickled_str = "{}"
-{}
+pickled_str = "{pickled_data}"
+{PYTHON_CHILD_SCRIPT}
             "#,
-            pickled_data, PYTHON_CHILD_SCRIPT,
         );
 
         // Create a ForkRequest message
@@ -437,15 +398,15 @@ pickled_str = "{}"
         };
 
         let fork_json = serde_json::to_string(&Message::ForkRequest(fork_request))
-            .map_err(|e| format!("Failed to serialize fork request: {}", e))?;
+            .map_err(|e| format!("Failed to serialize fork request: {e}"))?;
 
         // Send the message to the child process
-        writeln!(env_guard.stdin, "{}", fork_json)
-            .map_err(|e| format!("Failed to write to child stdin: {}", e))?;
+        writeln!(env_guard.stdin, "{fork_json}")
+            .map_err(|e| format!("Failed to write to child stdin: {e}"))?;
         env_guard
             .stdin
             .flush()
-            .map_err(|e| format!("Failed to flush child stdin: {}", e))?;
+            .map_err(|e| format!("Failed to flush child stdin: {e}"))?;
 
         // Release the lock so we don't block other operations
         drop(env_guard);
@@ -479,13 +440,13 @@ pickled_str = "{}"
         info!("Stopping isolated process: {}", process_uuid);
         let env_guard = environment
             .lock()
-            .map_err(|e| format!("Failed to lock environment mutex: {}", e))?;
+            .map_err(|e| format!("Failed to lock environment mutex: {e}"))?;
 
         // Check if the process UUID exists
         let forked_processes = env_guard
             .forked_processes
             .lock()
-            .map_err(|e| format!("Failed to lock forked processes: {}", e))?;
+            .map_err(|e| format!("Failed to lock forked processes: {e}"))?;
 
         if !forked_processes.contains_key(process_uuid) {
             warn!("No forked process found with UUID: {}", process_uuid);
@@ -518,21 +479,21 @@ pickled_str = "{}"
         let mut forked_processes = env_guard
             .forked_processes
             .lock()
-            .map_err(|e| format!("Failed to lock forked processes: {}", e))?;
+            .map_err(|e| format!("Failed to lock forked processes: {e}"))?;
         forked_processes.remove(process_uuid);
         drop(forked_processes);
 
         let mut fork_resolvers = env_guard
             .fork_resolvers
             .lock()
-            .map_err(|e| format!("Failed to lock fork resolvers: {}", e))?;
+            .map_err(|e| format!("Failed to lock fork resolvers: {e}"))?;
         fork_resolvers.remove(process_uuid);
         drop(fork_resolvers);
 
         let mut completion_resolvers = env_guard
             .completion_resolvers
             .lock()
-            .map_err(|e| format!("Failed to lock completion resolvers: {}", e))?;
+            .map_err(|e| format!("Failed to lock completion resolvers: {e}"))?;
         completion_resolvers.remove(process_uuid);
         drop(completion_resolvers);
 
@@ -551,19 +512,16 @@ pickled_str = "{}"
 
         let env_guard = environment
             .lock()
-            .map_err(|e| format!("Failed to lock environment mutex: {}", e))?;
+            .map_err(|e| format!("Failed to lock environment mutex: {e}"))?;
 
         // Check if the process exists
         let forked_processes = env_guard
             .forked_processes
             .lock()
-            .map_err(|e| format!("Failed to lock forked processes: {}", e))?;
+            .map_err(|e| format!("Failed to lock forked processes: {e}"))?;
 
         if !forked_processes.contains_key(process_uuid) {
-            return Err(format!(
-                "No forked process found with UUID: {}",
-                process_uuid
-            ));
+            return Err(format!("No forked process found with UUID: {process_uuid}"));
         }
         drop(forked_processes);
 
@@ -571,14 +529,13 @@ pickled_str = "{}"
         let completion_resolvers = env_guard
             .completion_resolvers
             .lock()
-            .map_err(|e| format!("Failed to lock completion resolvers: {}", e))?;
+            .map_err(|e| format!("Failed to lock completion resolvers: {e}"))?;
 
         let completion_resolver = match completion_resolvers.get(process_uuid) {
             Some(resolver) => resolver.clone(),
             None => {
                 return Err(format!(
-                    "No completion resolver found for UUID: {}",
-                    process_uuid
+                    "No completion resolver found for UUID: {process_uuid}"
                 ))
             }
         };
@@ -686,7 +643,7 @@ mod tests {
 
         // Get the PID of the initial Python process
         let initial_pid = runner.layer.as_ref().unwrap().lock().unwrap().child.id();
-        println!("Initial process PID: {:?}", initial_pid);
+        println!("Initial process PID: {initial_pid:?}");
 
         // First, prime the system by calling process_all_py_files to establish a baseline
         let _ = runner.ast_manager.process_all_py_files().unwrap();
@@ -700,15 +657,14 @@ mod tests {
         );
 
         // The environment should NOT have been updated (return false)
-        assert_eq!(
-            no_change_result.unwrap(),
-            false,
+        assert!(
+            !no_change_result.unwrap(),
             "Environment should not have been updated when imports didn't change"
         );
 
         // Get the PID after update with no changes
         let unchanged_pid = runner.layer.as_ref().unwrap().lock().unwrap().child.id();
-        println!("PID after no changes: {:?}", unchanged_pid);
+        println!("PID after no changes: {unchanged_pid:?}");
 
         // Verify that the process was NOT restarted (PIDs should be the same)
         assert_eq!(
@@ -739,7 +695,7 @@ mod tests {
 
         // Get the PID of the new Python process
         let new_pid = runner.layer.as_ref().unwrap().lock().unwrap().child.id();
-        println!("New process PID after import changes: {:?}", new_pid);
+        println!("New process PID after import changes: {new_pid:?}");
     }
 
     #[test]
@@ -787,14 +743,13 @@ def main():
 
         // The result should be our timestamp string
         let result_str = result_option.unwrap();
-        println!("Result from time.time(): {}", result_str);
+        println!("Result from time.time(): {result_str}");
 
         // Try to parse the result as a float to verify it's a valid timestamp
         let parsed_result = result_str.parse::<f64>();
         assert!(
             parsed_result.is_ok(),
-            "Failed to parse result as a float: {}",
-            result_str
+            "Failed to parse result as a float: {result_str}"
         );
 
         // Clean up by stopping the isolated process
@@ -851,7 +806,7 @@ def main():
             );
 
             let pid = *forked_processes.get(&test_uuid).unwrap();
-            println!("Process PID: {}", pid);
+            println!("Process PID: {pid}");
             drop(forked_processes);
         }
 
@@ -943,7 +898,7 @@ def main():
         let result = runner.communicate_isolated(&process_uuid);
 
         // Verify that we got an error
-        assert!(result.is_err(), "Expected an error but got: {:?}", result);
+        assert!(result.is_err(), "Expected an error but got: {result:?}");
 
         // Get the error message
         let error_message = result.err().unwrap();
@@ -951,16 +906,14 @@ def main():
         // The error should contain the specific error message
         assert!(
             error_message.contains("This is a custom error message"),
-            "Error should contain the custom error message but got: {}",
-            error_message
+            "Error should contain the custom error message but got: {error_message}"
         );
 
         // The error should contain traceback information
         assert!(
             error_message.contains("Traceback")
                 || error_message.contains("function_that_raises_error"),
-            "Error should contain traceback information but got: {}",
-            error_message
+            "Error should contain traceback information but got: {error_message}"
         );
 
         // Clean up