datablock support

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

Author: starpit

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

@@ -381,11 +381,51 @@ pub struct MessageBlock {
     pub tool_call_id: Option<String>,
 }
 
+/// Return the object where the value of each field is defined by a
+/// block. If the body of the object is an array, the resulting object
+/// is the union of the objects computed by each element of the array.
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ObjectBlock {
     pub object: HashMap<String, PdlBlock>,
 }
 
+/// Arbitrary value, equivalent to JSON.
+///
+/// Example. As part of a `defs` section, set `numbers` to the list `[1, 2, 3, 4]`:
+/// ```PDL
+/// defs:
+///   numbers:
+///     data: [1, 2, 3, 4]
+/// ```
+///
+/// Example.  Evaluate `${ TEST.answer }` in
+/// [Jinja](https://jinja.palletsprojects.com/en/stable/), passing
+/// the result to a regex parser with capture groups.  Set
+/// `EXTRACTED_GROUND_TRUTH` to an object with attribute `answer`,
+/// a string, containing the value of the capture group.
+/// ```PDL
+/// - data: ${ TEST.answer }
+///   parser:
+///     regex: "(.|\\n)*#### (?P<answer>([0-9])*)\\n*"
+///     spec:
+///       answer: str
+///   def: EXTRACTED_GROUND_TRUTH
+/// ```
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct DataBlock {
+    pub data: Value,
+
+    /// Do not evaluate expressions inside strings.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub raw: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub def: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub parser: Option<PdlParser>,
+}
+
 /// Execute a piece of Python code.
 ///
 /// Example:
@@ -491,6 +531,7 @@ pub enum PdlBlock {
     String(String),
     If(IfBlock),
     Include(IncludeBlock),
+    Data(DataBlock),
     Object(ObjectBlock),
     Call(CallBlock),
     Array(ArrayBlock),
@@ -557,6 +598,11 @@ impl From<String> for PdlResult {
         PdlResult::String(s)
     }
 }
+impl From<&bool> for PdlResult {
+    fn from(b: &bool) -> Self {
+        PdlResult::Bool(*b)
+    }
+}
 impl From<Number> for PdlResult {
     fn from(n: Number) -> Self {
         PdlResult::Number(n)

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

@@ -25,7 +25,7 @@ use serde_json::{from_str, to_string, Value};
 use serde_norway::{from_reader, from_str as from_yaml_str};
 
 use crate::pdl::ast::{
-    ArrayBlock, CallBlock, Closure, FunctionBlock, IfBlock, IncludeBlock, ListOrString,
+    ArrayBlock, CallBlock, Closure, DataBlock, FunctionBlock, IfBlock, IncludeBlock, ListOrString,
     MessageBlock, ModelBlock, ObjectBlock, PdlBlock, PdlParser, PdlResult, PdlUsage,
     PythonCodeBlock, ReadBlock, RepeatBlock, Role, Scope, SequencingBlock, StringOrBoolean,
 };
@@ -102,6 +102,7 @@ impl<'a> Interpreter<'a> {
             PdlBlock::If(block) => self.run_if(block, context).await,
             PdlBlock::Include(block) => self.run_include(block, context).await,
             PdlBlock::Model(block) => self.run_model(block, context).await,
+            PdlBlock::Data(block) => self.run_data(block, context).await,
             PdlBlock::Object(block) => self.run_object(block, context).await,
             PdlBlock::PythonCode(block) => self.run_python_code(block, context).await,
             PdlBlock::Read(block) => self.run_read(block, context).await,
@@ -183,7 +184,6 @@ impl<'a> Interpreter<'a> {
                     })
                     .collect::<Result<_, _>>()?,
             )),
-            //            v => Ok(v.clone()),
         }
     }
 
@@ -575,6 +575,39 @@ impl<'a> Interpreter<'a> {
         }
     }
 
+    fn resultify(&self, value: &Value) -> PdlResult {
+        match value {
+            Value::Null => "".into(),
+            Value::Bool(b) => b.into(),
+            Value::Number(n) => n.clone().into(),
+            Value::String(s) => s.clone().into(),
+            Value::Array(a) => {
+                PdlResult::List(a.iter().map(|v| self.resultify(v)).collect::<Vec<_>>())
+            }
+            Value::Object(m) => PdlResult::Dict(
+                m.iter()
+                    .map(|(k, v)| (k.clone(), self.resultify(v)))
+                    .collect::<HashMap<_, _>>(),
+            ),
+        }
+    }
+
+    async fn run_data(&mut self, block: &DataBlock, _context: Context) -> Interpretation {
+        if self.debug {
+            eprintln!("Data raw={:?} {:?}", block.raw, block.data);
+        }
+
+        let mut trace = block.clone();
+        if let Some(true) = block.raw {
+            let result = self.def(&block.def, &self.resultify(&block.data), &block.parser)?;
+            Ok((result, vec![], PdlBlock::Data(trace)))
+        } else {
+            let result = self.def(&block.def, &self.eval_complex(&block.data)?, &block.parser)?;
+            trace.data = from_str(to_string(&result)?.as_str())?;
+            Ok((result, vec![], PdlBlock::Data(trace)))
+        }
+    }
+
     async fn run_object(&mut self, block: &ObjectBlock, context: Context) -> Interpretation {
         if self.debug {
             eprintln!("Object {:?}", block.object);
@@ -583,6 +616,7 @@ impl<'a> Interpreter<'a> {
         let mut messages = vec![];
         let mut result_map = HashMap::new();
         let mut trace_map = HashMap::new();
+
         let mut iter = block.object.iter();
         while let Some((k, v)) = iter.next() {
             let (this_result, this_messages, this_trace) =
@@ -679,28 +713,22 @@ impl<'a> Interpreter<'a> {
 
     async fn process_defs(
         &mut self,
-        map: &Option<HashMap<String, PdlBlock>>,
+        defs: &Option<HashMap<String, PdlBlock>>,
     ) -> Result<(), PdlError> {
-        let cur_scope = self.scope.last().unwrap_or(&HashMap::new()).clone();
-        let new_scope = match map {
-            Some(defs) => {
-                // this is all non-optimal
-                let mut scope: Scope = HashMap::from(cur_scope);
-                let mut iter = defs.iter();
-                while let Some((var, def)) = iter.next() {
-                    let (result, _, _) = self.run_quiet(def, vec![]).await?;
-                    scope.insert(
-                        var.clone(),
-                        result,
-                        //from_str(to_string(&block).unwrap().as_str()).unwrap(),
-                    );
-                }
-                scope
+        let mut new_scope: Scope = HashMap::new();
+        if let Some(cur_scope) = self.scope.last() {
+            new_scope.extend(cur_scope.clone());
+        }
+        self.scope.push(new_scope);
+
+        if let Some(defs) = defs {
+            let mut iter = defs.iter();
+            while let Some((var, def)) = iter.next() {
+                let (result, _, _) = self.run_quiet(def, vec![]).await?;
+                let _ = self.def(&Some(var.clone()), &result, &None);
             }
-            None => cur_scope,
-        };
+        }
 
-        self.scope.push(new_scope);
         Ok(())
     }
 
@@ -737,6 +765,7 @@ impl<'a> Interpreter<'a> {
             output_messages.extend(this_messages);
             output_blocks.push(trace);
         }
+
         self.scope.pop();
 
         let trace = block.with_items(output_blocks);

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

@@ -469,4 +469,43 @@ mod tests {
         assert_eq!(messages[0].content, "hello world 4 bye");
         Ok(())
     }
+
+    #[test]
+    fn text_data_1() -> Result<(), Box<dyn Error>> {
+        let program = json!({
+            "include": "./tests/cli/data1.pdl"
+        });
+
+        let (_, messages, _) = run_json(program, false)?;
+        assert_eq!(messages.len(), 1);
+        assert_eq!(messages[0].role, MessageRole::User);
+        assert_eq!(messages[0].content, "xxxx3true");
+        Ok(())
+    }
+
+    #[test]
+    fn text_data_2() -> Result<(), Box<dyn Error>> {
+        let program = json!({
+            "include": "./tests/cli/data2.pdl"
+        });
+
+        let (_, messages, _) = run_json(program, false)?;
+        assert_eq!(messages.len(), 1);
+        assert_eq!(messages[0].role, MessageRole::User);
+        assert_eq!(messages[0].content, "xxxx3true");
+        Ok(())
+    }
+
+    #[test]
+    fn text_data_3() -> Result<(), Box<dyn Error>> {
+        let program = json!({
+            "include": "./tests/cli/data3.pdl"
+        });
+
+        let (_, messages, _) = run_json(program, false)?;
+        assert_eq!(messages.len(), 1);
+        assert_eq!(messages[0].role, MessageRole::User);
+        assert_eq!(messages[0].content, "${x}3true");
+        Ok(())
+    }
 }

pdl-live-react/src-tauri/tests/cli/data1.pdl

@@ -0,0 +1,11 @@
+lastOf:
+  - def: x
+    text:
+      - xxxx
+  - def: y
+    data:
+      n: 3
+      x: ${x}
+      b: true
+  - ${y.x~y.n~y.b}
+  

pdl-live-react/src-tauri/tests/cli/data2.pdl

@@ -0,0 +1,12 @@
+defs:
+  x:
+    text:
+      - xxxx
+  y:
+    data:
+      n: 3
+      x: ${x}
+      b: true
+lastOf:
+   - ${y.x~y.n~y.b}
+  

pdl-live-react/src-tauri/tests/cli/data3.pdl

@@ -0,0 +1,12 @@
+lastOf:
+  - def: x
+    text:
+      - xxxx
+  - def: y
+    raw: true
+    data:
+      n: 3
+      x: ${x}
+      b: true
+  - ${y.x~y.n~y.b}
+