clippy

Author: marcomq

Cargo.toml

@@ -15,7 +15,7 @@ dunce = "1.0.4"
 serde_json = "1.0.114"
 thiserror = "2.0"
 once_cell = "1.19"
-tokio = { version = "1.36.0", features = ["sync", "macros"] }
+tokio = { version = "1.47.0", features = ["sync", "macros", "rt", "rt-multi-thread"] }
 
 [features]
 default = ["pyo3"]
@@ -28,19 +28,16 @@ version = "0.26.0"
 features = ["auto-initialize"]
 optional = true
 
-
-[dev-dependencies]
-tempfile = "3"
 [dependencies.rustpython-vm]
 version = "0.4.0"
 optional = true
 features = ["threading", "serde", "importlib"]
+
 [dependencies.rustpython-stdlib]
 version = "0.4.0"
 optional = true
 features = ["threading"]
 
-# The `full` feature for tokio is needed for the tests
-[dev-dependencies.tokio]
-version = "1"
-features = ["full"]
+[dev-dependencies]
+tempfile = "3"
+tokio = { version = "1.47.0", features = ["full"] }

src/lib.rs

@@ -92,6 +92,13 @@ pub struct PyRunner {
     sender: mpsc::Sender<PyCommand>,
 }
 
+
+impl Default for PyRunner {
+    fn default() -> Self {
+        PyRunner::new()
+    }
+}
+
 impl PyRunner {
     /// Creates a new `PyRunner` and spawns a dedicated thread for Python execution.
     ///
@@ -153,14 +160,13 @@ impl PyRunner {
         let (tx, rx) = std_mpsc::channel();
         let sender = self.sender.clone();
 
-        let cmd_type_clone = cmd_type; // Clone is implicit as CmdType is Copy
         let task = Box::new(move |rt: &Runtime| {
             let result = rt.block_on(async {
                 // This is the async `send_command` logic, but we can't call it
                 // directly because of `&self` lifetime issues inside the closure.
                 let (responder, receiver) = oneshot::channel();
                 let cmd = PyCommand {
-                    cmd_type: cmd_type_clone,
+                    cmd_type,
                     responder,
                 };
                 sender
@@ -186,6 +192,7 @@ impl PyRunner {
     /// Asynchronously executes a block of Python code.
     ///
     /// * `code`: A string slice containing the Python code to execute.
+    ///
     /// This is equivalent to Python's `exec()` function.
     pub async fn run(&self, code: &str) -> Result<(), PyRunnerError> {
         self.send_command(CmdType::RunCode(code.into()))
@@ -208,6 +215,7 @@ impl PyRunner {
 
     /// Asynchronously runs a python file.
     /// * `file`: Absolute path to a python file to execute.
+    ///
     /// Also loads the path of the file to sys.path for imports.
     pub async fn run_file(&self, file: &Path) -> Result<(), PyRunnerError> {
         self.send_command(CmdType::RunFile(file.to_path_buf()))
@@ -230,8 +238,8 @@ impl PyRunner {
 
     /// Asynchronously evaluates a single Python expression.
     ///
-    /// * `code`: A string slice containing the Python expression to evaluate.
-    ///           Must not contain definitions or multiple lines.
+    /// * `code`: A string slice containing the Python expression to evaluate. Must not contain definitions or multiple lines.
+    ///
     /// Returns a `Result` containing the expression's result as a `serde_json::Value` on success,
     /// or a `PyRunnerError` on failure. This is equivalent to Python's `eval()` function.
     pub async fn eval(&self, code: &str) -> Result<Value, PyRunnerError> {
@@ -254,6 +262,7 @@ impl PyRunner {
     ///
     /// * `var_name`: The name of the variable to read. It can be a dot-separated path
     ///   to access attributes of objects (e.g., "my_module.my_variable").
+    ///
     /// Returns the variable's value as a `serde_json::Value` on success.
     pub async fn read_variable(&self, var_name: &str) -> Result<Value, PyRunnerError> {
         self.send_command(CmdType::ReadVariable(var_name.into()))
@@ -277,6 +286,7 @@ impl PyRunner {
     /// * `name`: The name of the function to call. It can be a dot-separated path
     ///   to access functions within modules (e.g., "my_module.my_function").
     /// * `args`: A vector of `serde_json::Value` to pass as arguments to the function.
+    ///
     /// Returns the function's return value as a `serde_json::Value` on success.
     /// Does not release GIL during await.
     pub async fn call_function(
@@ -313,6 +323,7 @@ impl PyRunner {
     /// * `name`: The name of the function to call. It can be a dot-separated path
     ///   to access functions within modules (e.g., "my_module.my_function").
     /// * `args`: A vector of `serde_json::Value` to pass as arguments to the function.
+    ///
     /// Returns the function's return value as a `serde_json::Value` on success.
     /// Will release GIL during await.
     pub async fn call_async_function(
@@ -374,7 +385,7 @@ impl PyRunner {
             )));
         }
         let set_venv_code = include_str!("set_venv.py");
-        self.run(&set_venv_code).await?;
+        self.run(set_venv_code).await?;
 
         let site_packages = if cfg!(target_os = "windows") {
             venv_path.join("Lib").join("site-packages")
@@ -415,7 +426,7 @@ impl PyRunner {
             )));
         }
         let set_venv_code = include_str!("set_venv.py");
-        self.run_sync(&set_venv_code)?;
+        self.run_sync(set_venv_code)?;
 
         let site_packages = if cfg!(target_os = "windows") {
             venv_path.join("Lib").join("site-packages")

src/pyo3_runner.rs

@@ -25,22 +25,22 @@ pub(crate) async fn python_thread_main(mut receiver: mpsc::Receiver<PyCommand>)
             let result = match std::mem::replace(&mut cmd.cmd_type, CmdType::Stop) {
                 CmdType::RunCode(code) => {
                     let c_code = CString::new(code).expect("CString::new failed");
-                    py.run(&c_code, Some(&globals), None).map(|_| Value::Null)
+                    py.run(&c_code, Some(globals), None).map(|_| Value::Null)
                 }
                 CmdType::EvalCode(code) => {
                     let c_code = CString::new(code).expect("CString::new failed");
-                    py.eval(&c_code, Some(&globals), None)
-                        .and_then(|obj| py_any_to_json(py, &obj))
+                    py.eval(&c_code, Some(globals), None)
+                        .and_then(|obj| py_any_to_json(&obj))
                 }
-                CmdType::RunFile(file) => handle_run_file(py, &globals, file),
+                CmdType::RunFile(file) => handle_run_file(py, globals, file),
                 CmdType::ReadVariable(var_name) => {
-                    get_py_object(&globals, &var_name).and_then(|obj| py_any_to_json(py, &obj))
+                    get_py_object(globals, &var_name).and_then(|obj| py_any_to_json(&obj))
                 }
                 CmdType::CallFunction { name, args } => {
-                    handle_call_function(py, &globals, name, args)
+                    handle_call_function(py, globals, name, args)
                 }
                 CmdType::CallAsyncFunction { name, args } => {
-                    let func = get_py_object(&globals, &name).unwrap(); // TODO;
+                    let func = get_py_object(globals, &name).unwrap(); // TODO;
                     check_func_callable(&func, &name).unwrap(); // TODO
                     let func = func.unbind();
 
@@ -110,7 +110,7 @@ with open({}, 'r') as f:
         print_path_for_python(&file.to_path_buf())
     );
     let c_code = CString::new(code).expect("CString::new failed");
-    py.run(&c_code, Some(&globals), None).map(|_| Value::Null)
+    py.run(&c_code, Some(globals), None).map(|_| Value::Null)
 }
 
 /// Handles the `CallFunction` command.
@@ -124,7 +124,7 @@ fn handle_call_function(
     check_func_callable(&func, &name)?;
     let t_args = vec_to_py_tuple(&py, args)?;
     let result = func.call1(t_args)?;
-    py_any_to_json(py, &result)
+    py_any_to_json(&result)
 }
 
 fn vec_to_py_tuple<'py>(
@@ -155,13 +155,13 @@ async fn handle_call_async_function(
         let result = loop_obj.call_method1("run_until_complete", (coroutine,))?;
         loop_obj.call_method0("close")?;
 
-        py_any_to_json(py, &result)
+        py_any_to_json(&result)
     });
     let _ = responder.send(result.map_err(|e| e.to_string()));
 }
 
 /// Recursively converts a Python object to a `serde_json::Value`.
-fn py_any_to_json(py: Python, obj: &pyo3::Bound<'_, PyAny>) -> PyResult<Value> {
+fn py_any_to_json(obj: &pyo3::Bound<'_, PyAny>) -> PyResult<Value> {
     if obj.is_none() {
         return Ok(Value::Null);
     }
@@ -186,13 +186,13 @@ fn py_any_to_json(py: Python, obj: &pyo3::Bound<'_, PyAny>) -> PyResult<Value> {
     }
     if let Ok(list) = obj.cast::<PyList>() {
         let items: PyResult<Vec<Value>> =
-            list.iter().map(|item| py_any_to_json(py, &item)).collect();
+            list.iter().map(|item| py_any_to_json(&item)).collect();
         return Ok(Value::Array(items?));
     }
     if let Ok(dict) = obj.cast::<PyDict>() {
         let mut map = serde_json::Map::new();
         for (key, value) in dict.iter() {
-            map.insert(key.to_string(), py_any_to_json(py, &value)?);
+            map.insert(key.to_string(), py_any_to_json(&value)?);
         }
         return Ok(Value::Object(map));
     }