fixing rustpython

Author: marcomq

Cargo2.toml

@@ -18,6 +18,7 @@ use tokio::sync::{mpsc, oneshot};
 
 #[derive(Debug)]
 pub(crate) enum CmdType {
+    RunFile(PathBuf),
     RunCode(String),
     EvalCode(String),
     ReadVariable(String),
@@ -131,16 +132,9 @@ impl PyRunner {
     /// * `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> {
-        let sys_import = format!(
-            r#"
-import sys
-sys.path = sys.path + [{}]
-"#,
-            print_path_for_python(&file.parent().unwrap().to_path_buf()),
-        );
-        self.run(&sys_import).await?;
-        let code = tokio::fs::read_to_string(file).await.map_err(|e| PyRunnerError::PyError(e.to_string()))?;
-        self.run(&code).await
+        self.send_command(CmdType::RunFile(file.to_path_buf()))
+            .await
+            .map(|_| ())
     }
 
     /// Asynchronously evaluates a single Python expression.

src/lib.rs

@@ -3,7 +3,7 @@
 //  Licensed under MIT License, see License file for more details
 //  git clone https://github.com/marcomq/async_py
 
-use crate::{CmdType, PyCommand};
+use crate::{print_path_for_python, CmdType, PyCommand};
 use pyo3::{
     exceptions::PyKeyError,
     prelude::*,
@@ -31,6 +31,9 @@ pub(crate) fn python_thread_main(mut receiver: mpsc::Receiver<PyCommand>) {
                     py.eval(&c_code, Some(&globals), None)
                         .and_then(|obj| py_any_to_json(py, &obj))
                 }
+                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))
                 }
@@ -71,6 +74,25 @@ fn get_py_object<'py>(
     Ok(obj)
 }
 
+fn handle_run_file(
+    py: Python,
+    globals: &pyo3::Bound<'_, PyDict>,
+    file: std::path::PathBuf,
+) -> PyResult<Value> {
+        let code = format!(
+        r#"
+import sys
+sys.path.insert(0, {})
+with open({}, 'r') as f:
+    exec(f.read())
+"#,
+        print_path_for_python(&file.parent().unwrap().to_path_buf()),
+        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)
+}
+
 /// Handles the `CallFunction` command.
 fn handle_call_function(
     py: Python,

src/pyo3_runner.rs

@@ -31,6 +31,9 @@ pub(crate) fn python_thread_main(mut receiver: mpsc::Receiver<PyCommand>) {
                     .map(|_| Value::Null),
                 CmdType::EvalCode(code) => eval::eval(vm, code, scope.clone(), "<string, eval>")
                     .and_then(|obj| py_to_json(vm, &obj)),
+                CmdType::RunFile(file) => {
+                    handle_run_file(vm, scope.clone(), file).map(|_| Value::Null)
+                }
                 CmdType::ReadVariable(var_name) => {
                     read_variable(vm, scope.clone(), var_name).and_then(|obj| py_to_json(vm, &obj))
                 }
@@ -52,6 +55,16 @@ pub(crate) fn python_thread_main(mut receiver: mpsc::Receiver<PyCommand>) {
     });
 }
 
+fn handle_run_file(
+    vm: &VirtualMachine,
+    scope: Scope,
+    file: &std::path::PathBuf,
+) -> PyResult<()> {
+    let dir = file.parent().unwrap().to_str().unwrap();
+    vm.insert_sys_path(vm.new_pyobj(dir))?;
+    vm.run_script(scope, file.to_str().unwrap())
+}
+
 fn read_variable(vm: &VirtualMachine, scope: Scope, var_name: &str) -> PyResult<PyObjectRef> {
     let parts: Vec<String> = var_name.split('.').map(|s| s.to_owned()).collect();
     let mut obj = scope.globals.get_item(&parts[0], vm)?;