more more

Signed-off-by: Nick Mitchell <[email protected]>

Author: starpit

pdl-live-react/src-tauri/src/cli/run.rs

@@ -55,6 +55,7 @@ pub fn run_pdl_program(
             println!("Updated! {:?}", updated_program);
             let mut out_str = String::new();
             let mut emitter = YamlEmitter::new(&mut out_str);
+            emitter.multiline_strings(true);
             emitter.dump(&updated_program).map_err(|e| match e {
                 EmitError::FmtError(ee) => tauri::Error::Anyhow(ee.into()),
             })?;

pdl-live-react/src-tauri/src/interpreter/extract.rs

@@ -38,25 +38,28 @@ pub fn extract_requirements(program: &Yaml) -> (Vec<String>, Yaml) {
 
                     let req_hash = shasum::sha256sum_str(requirements_text.as_str()).unwrap();
                     let code_text = if let Some(c) = h[&code].as_str() {
-                        c
+                        format!("{}\nprint(result)", c)
                     } else {
-                        ""
+                        "".to_string()
                     };
-                    let code_hash = shasum::sha256sum_str(code_text).unwrap();
+                    let code_hash = shasum::sha256sum_str(&code_text.as_str()).unwrap();
 
                     let tmp = Builder::new()
                         .prefix(&format!("pdl-program-{}", code_hash))
                         .suffix(".pdl")
                         .tempfile()
                         .unwrap(); // TODO tmpfile_in(source dir)
                     write(&tmp, code_text).unwrap();
+                    let (_, tmp_path) = tmp.keep().unwrap();
 
                     h.remove(&requirements);
+                    h[&lang] = Yaml::String("command".to_string());
+                    h.insert(Yaml::String("file".to_string()), Yaml::Boolean(true));
                     h[&code] = Yaml::String(format!(
-                        "\"/Users/nickm/Library/Caches/pdl/venvs/{}/{}/python /tmp/{}.pdl\"",
+                        "\"/Users/nickm/Library/Caches/pdl/venvs/{}/{}/python {}\"",
                         req_hash,
                         if cfg!(windows) { "Scripts" } else { "bin" },
-                        code_hash
+                        tmp_path.display(),
                     ));
 
                     Yaml::Hash(h.clone())

pdl-live-react/src-tauri/src/interpreter/pip.rs

@@ -16,17 +16,12 @@ fn pip_install_if_needed_with_hash(
     cache_path: &Path,
     requirements_path: &Path,
     hash: String,
-    force: bool,
 ) -> Result<PathBuf, tauri::Error> {
     create_dir_all(&cache_path)?;
 
     let venv_path = cache_path.join("venvs").join(hash);
     let bin_path = venv_path.join(if cfg!(windows) { "Scripts" } else { "bin" });
 
-    // re: force, this is part of the short-term hack to install all
-    // code block dependencies in the main interpreter venv. Once we
-    // figure out how to support a separate venv for each code block
-    // (that needs it), we can undo this hack.
     if !venv_path.exists() {
         println!("Creating virtual environment...");
         let python = if cfg!(target_os = "macos") {
@@ -36,16 +31,10 @@ fn pip_install_if_needed_with_hash(
         };
         cmd!(python, "-mvenv", &venv_path).run()?;
 
-        if !force {
-            cmd!(bin_path.join("pip"), "install", "-r", &requirements_path).run()?;
-
-            let cached_requirements_path = venv_path.join("requirements.txt");
-            copy(requirements_path, cached_requirements_path)?;
-        }
-    }
-
-    if force {
         cmd!(bin_path.join("pip"), "install", "-r", &requirements_path).run()?;
+
+        let cached_requirements_path = venv_path.join("requirements.txt");
+        copy(requirements_path, cached_requirements_path)?;
     }
 
     Ok(bin_path.to_path_buf())
@@ -57,7 +46,7 @@ fn pip_install_if_needed(
     requirements_path: &Path,
 ) -> Result<PathBuf, tauri::Error> {
     let hash = shasum::sha256sum(&requirements_path)?;
-    pip_install_if_needed_with_hash(cache_path, requirements_path, hash, false)
+    pip_install_if_needed_with_hash(cache_path, requirements_path, hash)
 }
 
 #[cfg(desktop)]
@@ -67,11 +56,6 @@ pub async fn pip_install_code_blocks_if_needed(
 ) -> Result<Option<Yaml>, tauri::Error> {
     let cache_path = app_handle.path().cache_dir()?.join("pdl");
 
-    // for now, install the requirements in the main interpreter venv
-    let requirements_path = app_handle
-        .path()
-        .resolve("interpreter/requirements.txt", BaseDirectory::Resource)?;
-
     let (reqs, updated_program) = extract::extract_requirements(&program);
     let n = reqs
         .into_par_iter()
@@ -80,12 +64,8 @@ pub async fn pip_install_code_blocks_if_needed(
                 .prefix("pdl-requirements-")
                 .suffix(".txt")
                 .tempfile()?;
-            // This is part of the "force" hack described above, where
-            // we force the code block dependencies to be installed in
-            // the main interpreter venv.
-            let hash = shasum::sha256sum(&requirements_path)?;
             write(&req_path, req)?;
-            pip_install_if_needed_with_hash(&cache_path, &req_path.path(), hash, true)?;
+            pip_install_if_needed(&cache_path, &req_path.path())?;
             Ok(1)
         })
         .count();

src/pdl/pdl_ast.py

@@ -475,6 +475,9 @@ class CodeBlock(LeafBlock):
     code: "BlockType"
     """Code to execute.
     """
+    file: Optional[bool] = None
+    """Code to execute is a file path.
+    """
 
     @model_validator(mode="after")
     def lang_is_python(self):

src/pdl/pdl_interpreter.py

@@ -1456,7 +1456,7 @@ def process_call_code(
                 ) from exc
         case "command":
             try:
-                result = call_command(code_s)
+                result = call_command(code_s, block.file == True)
                 background = PdlList(
                     [
                         PdlDict(  # type: ignore
@@ -1530,7 +1530,10 @@ def call_python(code: str, scope: ScopeType) -> PdlLazy[Any]:
     return PdlConst(result)
 
 
-def call_command(code: str) -> PdlLazy[str]:
+def call_command(code: str, is_file: bool) -> PdlLazy[str]:
+    if is_file:
+        with open(code, "r") as f:
+            code = f.read()
     args = shlex.split(code)
     p = subprocess.run(
         args, capture_output=True, text=True, check=False, shell=False