i think it's working now

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

Author: starpit

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

@@ -27,7 +27,7 @@ pub fn run_pdl_program(
     data: Option<&tauri_plugin_cli::ArgData>,
     stream: Option<&tauri_plugin_cli::ArgData>,
 ) -> Result<(), tauri::Error> {
-    println!(
+    eprintln!(
         "Running {:#?}",
         Path::new(&source_file_path).file_name().unwrap()
     );
@@ -78,7 +78,6 @@ pub fn run_pdl_program(
         _ => source_file_path.clone(),
     };
 
-    println!("SRC {} -> {}", source_file_path, updated_source_file_path);
     let mut args = vec![
         updated_source_file_path.clone(),
         dashdash("--trace", trace_file),
@@ -89,9 +88,9 @@ pub fn run_pdl_program(
     cmd(bin_path.join("pdl"), &args).run()?;
 
     // TODO how do we do this on all exit paths in rust?
-    /*if updated_source_file_path != source_file_path {
+    if updated_source_file_path != source_file_path {
         remove_file(updated_source_file_path)?;
-    }*/
+    }
 
     Ok(())
 }

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

@@ -1,6 +1,3 @@
-use ::std::fs::write;
-
-use tempfile::Builder;
 use yaml_rust2::Yaml;
 
 use crate::interpreter::shasum;
@@ -42,25 +39,28 @@ pub fn extract_requirements(program: &Yaml) -> (Vec<String>, Yaml) {
                     } else {
                         "".to_string()
                     };
-                    let code_hash = shasum::sha256sum_str(&code_text.as_str()).unwrap();
+                    //let code_hash = shasum::sha256sum_str(&code_text.as_str()).unwrap();
 
-                    let tmp = Builder::new()
+                    /*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();
+                    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 {}\"",
-                        req_hash,
-                        if cfg!(windows) { "Scripts" } else { "bin" },
-                        tmp_path.display(),
-                    ));
+                    //h.insert(&Yaml::String("file".to_string()), Yaml::Boolean(true));
+                    h[&code] = Yaml::Array(vec![
+                        Yaml::String(format!(
+                            "/Users/nickm/Library/Caches/pdl/venvs/{}/{}/python",
+                            req_hash,
+                            if cfg!(windows) { "Scripts" } else { "bin" },
+                        )),
+                        Yaml::String("-c".to_owned()),
+                        Yaml::String(code_text),
+                    ]);
 
                     Yaml::Hash(h.clone())
                 }

src/pdl/pdl_ast.py

@@ -472,19 +472,18 @@ class CodeBlock(LeafBlock):
     requirements: Optional[str | list[str]] = None
     """Pip requirements.txt
     """
-    code: "BlockType"
+    code: "BlockOrBlocksType"
     """Code to execute.
     """
-    file: Optional[bool] = None
-    """Code to execute is a file path.
-    """
 
     @model_validator(mode="after")
     def lang_is_python(self):
         if self.requirements is not None and self.lang != "python":
             raise ValueError(
                 "CodeBlock requirements field provided for non-python block"
             )
+        if isinstance(self.code, list) and self.lang != "command":
+            raise ValueError("CodeBlock code field is array for non-command block")
         return self
 
 

src/pdl/pdl_ast_utils.py

@@ -48,7 +48,11 @@ def iter_block_children(f: Callable[[BlockType], None], block: BlockType) -> Non
             if block.pdl__trace is not None:
                 f(block.pdl__trace)
         case CodeBlock():
-            f(block.code)
+            if isinstance(block.code, list):
+                for b in block.code:
+                    f(b)
+            else:
+                f(block.code)
         case GetBlock():
             pass
         case DataBlock():
@@ -150,7 +154,10 @@ def map_block_children(f: MappedFunctions, block: BlockType) -> BlockType:
             if block.parameters is not None:
                 block.parameters = f.f_expr(block.parameters)
         case CodeBlock():
-            block.code = f.f_block(block.code)
+            if isinstance(block.code, list):
+                block.code = [f.f_block(b) for b in block.code]
+            else:
+                block.code = f.f_block(block.code)
         case GetBlock():
             pass
         case DataBlock():

src/pdl/pdl_dumper.py

@@ -135,7 +135,10 @@ def block_to_dict(  # noqa: C901
                 d["modelResponse"] = block.modelResponse
         case CodeBlock():
             d["lang"] = block.lang
-            d["code"] = block_to_dict(block.code, json_compatible)
+            if isinstance(block.code, list):
+                d["code"] = [block_to_dict(b, json_compatible) for b in block.code]
+            else:
+                d["code"] = block_to_dict(block.code, json_compatible)
             d["requirements"] = block.requirements
         case GetBlock():
             d["get"] = block.get

src/pdl/pdl_interpreter.py

@@ -1431,14 +1431,24 @@ def process_call_code(
     state: InterpreterState, scope: ScopeType, block: CodeBlock, loc: PdlLocationType
 ) -> tuple[PdlLazy[Any], LazyMessages, ScopeType, CodeBlock]:
     background: LazyMessages
-    code_, _, _, block = process_block_of(
-        block,
-        "code",
-        state.with_yield_result(False).with_yield_background(False),
-        scope,
-        loc,
-    )
-    code_s = code_.result()
+    code_a = None
+    if isinstance(block.code, list):
+        code_s = ""
+        code_a, _, _, _ = process_block(
+            state.with_yield_result(False).with_yield_background(False),
+            scope,
+            ArrayBlock(array=block.code),
+            loc,
+        )
+    else:
+        code_, _, _, block = process_block_of(
+            block,
+            "code",
+            state.with_yield_result(False).with_yield_background(False),
+            scope,
+            loc,
+        )
+        code_s = code_.result()
     match block.lang:
         case "python":
             try:
@@ -1456,7 +1466,7 @@ def process_call_code(
                 ) from exc
         case "command":
             try:
-                result = call_command(code_s, block.file == True)
+                result = call_command(code_s, code_a)
                 background = PdlList(
                     [
                         PdlDict(  # type: ignore
@@ -1530,11 +1540,11 @@ def call_python(code: str, scope: ScopeType) -> PdlLazy[Any]:
     return PdlConst(result)
 
 
-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)
+def call_command(code: str, code_a: PdlLazy[list[str]] | None) -> PdlLazy[str]:
+    if code_a is not None and isinstance(code_a.result(), list):
+        args = code_a.result()
+    else:
+        args = shlex.split(code)
     p = subprocess.run(
         args, capture_output=True, text=True, check=False, shell=False
     )  # nosec B603