fix: import should yield the result in streaming mode

Signed-off-by: Louis Mandel <[email protected]>

Author: mandel

examples/demos/react_call.pdl

@@ -1,10 +1,8 @@
 description: Wikipedia example using the react_fun function definition
-text:
-  - import: react_fun
-    def: lib
-  - call: ${ lib.react }
-    args:
-      question: "How many years ago was the discoverer of the Hudson River born? Keep in mind we are in 2025. When searching avoid using the words discovery or birthday.\n"
-      model: ollama_chat/granite3.3:8b
-
-
+defs:
+  lib:
+    import: react_fun
+call: ${ lib.react }
+args:
+  question: "How many years ago was the discoverer of the Hudson River born? Keep in mind we are in 2025. When searching avoid using the words discovery or birthday.\n"
+  model: ollama_chat/granite3.3:8b

examples/react/react_call.pdl

@@ -1,10 +1,8 @@
 description: Wikipedia example using the react_fun function definition
-text:
-  - import: react_fun
-    def: lib
-  - call: ${ lib.react }
-    args:
-      question: "How many years ago was the discoverer of the Hudson River born? Keep in mind we are in 2025. When searching avoid using the words discovery or birthday.\n"
-      model: ollama_chat/granite3.3:8b
-
-
+defs:
+  lib:
+    import: react_fun
+call: ${ lib.react }
+args:
+  question: "How many years ago was the discoverer of the Hudson River born? Keep in mind we are in 2025. When searching avoid using the words discovery or birthday.\n"
+  model: ollama_chat/granite3.3:8b

examples/tutorial/calling_llm_with_input_messages_var.pdl

@@ -1,12 +1,10 @@
 description: Model call with explicit messages input
-text:
-- def: prompt
-  array:
-  - role: system
-    content: You are a helpful software engineer. You write clear, concise, well-commented code.
-  - role: user
-    content: Write a Python function that implement merge sort.
-  contribute: []
-- model: ollama_chat/granite3.2:2b
-  input: ${ prompt }
-
+defs:
+  prompt:
+    array:
+    - role: system
+      content: You are a helpful software engineer. You write clear, concise, well-commented code.
+    - role: user
+      content: Write a Python function that implement merge sort.
+model: ollama_chat/granite3.2:2b
+input: ${ prompt }

src/pdl/pdl_interpreter.py

@@ -2009,6 +2009,8 @@ def process_import(
             prog.root,
             new_loc,
         )
+        if state.yield_result:
+            yield_result(new_scope, block.kind)
         import_trace = block.model_copy(update={"pdl__trace": trace})
         return new_scope, DependentContext([]), scope, import_trace
     except PDLParseError as exc:

tests/results/examples/react/react_call.0.result

@@ -0,0 +1,47 @@
+Here is a Python implementation of the Merge Sort algorithm:
+
+```python
+def merge_sort(arr):
+    # Base case: if array has 1 or no elements, it's already sorted
+    if len(arr) <= 1:
+        return arr
+
+    # Divide the array into two halves
+    mid = len(arr) // 2
+    left_half = arr[:mid]
+    right_half = arr[mid:]
+
+    # Recursively sort both halves
+    left_sorted = merge_sort(left_half)
+    right_sorted = merge_sort(right_half)
+
+    # Merge the sorted halves back together
+    return merge(left_sorted, right_sorted)
+
+def merge(left, right):
+    """
+    Merge two sorted arrays into one sorted array.
+    """
+    merged = []  # Initialize an empty list for the result
+    left_index = 0  # Index for the left array
+    right_index = 0  # Index for the right array
+
+    # Continue until we've iterated through both lists
+    while left_index < len(left) and right_index < len(right):
+        if left[left_index] <= right[right_index]:
+            merged.append(left[left_index])
+            left_index += 1
+        else:
+            merged.append(right[right_index])
+            right_index += 1
+
+    # If there are any remaining elements in either list, append them to the result
+    merged.extend(left[left_index:])
+    merged.extend(right[right_index:])
+
+    return merged
+```
+
+This code first checks if the array is already sorted (i.e., has one or zero elements). If so, it returns the array as is. Otherwise, it divides the array into two halves and recursively sorts each half. The `merge` function then combines these sorted halves back together to produce a single sorted array.
+
+The time complexity of Merge Sort is O(n log n) for all cases (best, average, worst), making it efficient even for large lists.