read block support

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

Author: starpit

pdl-live-react/src-tauri/src/pdl/ast.rs

@@ -232,6 +232,29 @@ fn lang_python() -> String {
     "python".to_string()
 }
 
+// Read from a file or standard input.
+//
+// Example. Read from the standard input with a prompt starting with `> `.
+// ```PDL
+// read:
+// message: "> "
+// ```
+//
+// Example. Read the file `./data.yaml` in the same directory of the PDL file containing the block and parse it into YAML.
+// ```PDL
+// read: ./data.yaml
+// parser: yaml
+// ```
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct PdlReadBlock {
+    // Name of the file to read. If `None`, read the standard input.
+    pub read: Value,
+    // Name of the file to read. If `None`, read the standard input.
+    pub message: Option<String>,
+    // Indicate if one or multiple lines should be read.
+    pub multiline: Option<bool>,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(untagged)]
 pub enum PdlBlock {
@@ -252,6 +275,7 @@ pub enum PdlBlock {
     Model(PdlModelBlock),
     Function(PdlFunctionBlock),
     PythonCode(PdlPythonCodeBlock),
+    Read(PdlReadBlock),
 }
 
 impl From<&str> for PdlBlock {

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

@@ -3,7 +3,7 @@ use ::std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 // use ::std::env::current_dir;
 use ::std::error::Error;
-use ::std::fs::File;
+use ::std::fs::{read_to_string as read_file_to_string, File};
 // use ::std::path::PathBuf;
 
 use async_recursion::async_recursion;
@@ -25,8 +25,8 @@ use serde_json::{from_str, to_string, Map, Value};
 use serde_norway::{from_reader, from_str as from_yaml_str};
 
 use crate::pdl::ast::{
-    PdlBlock, PdlCallBlock, PdlModelBlock, PdlParser, PdlPythonCodeBlock, PdlRepeatBlock,
-    PdlTextBlock, PdlUsage, Role,
+    PdlBlock, PdlCallBlock, PdlModelBlock, PdlParser, PdlPythonCodeBlock, PdlReadBlock,
+    PdlRepeatBlock, PdlTextBlock, PdlUsage, Role,
 };
 
 type Context = Vec<ChatMessage>;
@@ -84,6 +84,7 @@ impl<'a> Interpreter<'a> {
             PdlBlock::Call(block) => self.run_call(block, context).await,
             PdlBlock::PythonCode(block) => self.run_python_code(block, context).await,
             PdlBlock::Model(block) => self.run_model(block, context).await,
+            PdlBlock::Read(block) => self.run_read(block, context).await,
             PdlBlock::Repeat(block) => self.run_repeat(block, context).await,
             PdlBlock::Text(block) => self.run_text(block, context).await,
             _ => Err(Box::from(format!("Unsupported block {:?}", program))),
@@ -148,6 +149,30 @@ impl<'a> Interpreter<'a> {
         Ok((messages, trace))
     }
 
+    // Run a PdlBlock::Read
+    async fn run_read(&self, block: &PdlReadBlock, _context: Context) -> Interpretation {
+        let trace = block.clone();
+
+        if let Some(message) = &block.message {
+            println!("{}", message);
+        }
+
+        let buffer = match &block.read {
+            Value::String(file_path) => Ok(read_file_to_string(file_path)?),
+            Value::Null => {
+                let mut buffer = String::new();
+                ::std::io::stdin().read_line(&mut buffer)?;
+                Ok(buffer)
+            }
+            x => Err(Box::<dyn Error + Send + Sync>::from(format!(
+                "Unsupported value for read field: {:?}",
+                x
+            ))),
+        }?;
+
+        Ok((vec![ChatMessage::user(buffer)], PdlBlock::Read(trace)))
+    }
+
     // Run a PdlBlock::Call
     async fn run_call(&mut self, block: &PdlCallBlock, context: Context) -> Interpretation {
         if self.debug {

pdl-live-react/src-tauri/src/pdl/interpreter_tests.rs

@@ -206,4 +206,18 @@ mod tests {
         assert_eq!(messages[0].content, "{'foo': 3}");
         Ok(())
     }
+
+    #[test]
+    fn text_read_file() -> Result<(), Box<dyn Error>> {
+        let program = json!({
+            "message": "Read a file",
+            "read":"./tests/data/foo.txt"
+        });
+
+        let (messages, _) = run_json(program, false)?;
+        assert_eq!(messages.len(), 1);
+        assert_eq!(messages[0].role, MessageRole::User);
+        assert_eq!(messages[0].content, "this should be foo\n");
+        Ok(())
+    }
 }