dependent/independent context implementation

Signed-off-by: Mandana Vaziri <[email protected]>

Author: vazirim

examples/tutorial/independent.pdl

@@ -1,4 +1,4 @@
-description: Independent example -- hello * ( ' in French' + ' en Espanol') * Goodbye! 
+description: Independent example -- hello * ( (' in French'*g) + (' en Espanol'*g)) * Goodbye! * g 
 text:
   - hello
   - context: independent
@@ -9,5 +9,5 @@ text:
     - text:
       - " en Espanol!"
       - model: ollama_chat/granite3.2:2b
-  - "Goodbye!"
+  - "Which language did I use last?"
   - model: ollama_chat/granite3.2:2b

examples/tutorial/independent_docs.pdl

@@ -6,4 +6,5 @@ text:
     text:
     - ${ doc1 }
     - ${ doc2 }
+  - Compare and contrast the above documents.
   - model: ollama_chat/granite3.2:2b

src/pdl/pdl_ast.py

@@ -25,6 +25,7 @@
 from pydantic.json_schema import SkipJsonSchema
 from typing_extensions import TypeAliasType
 
+from .pdl_context import DependentContext
 from .pdl_lazy import PdlDict, PdlLazy
 
 
@@ -41,7 +42,7 @@ def _ensure_lower(value):
 
 
 LazyMessage: TypeAlias = PdlLazy[dict[str, Any]]
-LazyMessages: TypeAlias = PdlLazy[list[dict[str, Any]]]
+LazyMessages: TypeAlias = DependentContext
 
 
 class BlockKind(StrEnum):

src/pdl/pdl_context.py

@@ -0,0 +1,74 @@
+from typing import Any
+from enum import StrEnum
+from .pdl_lazy import (
+    PdlDict,
+    PdlList,
+    PdlLazy,
+)
+
+class SerializeMode(StrEnum):
+    LITELLM = "litellm"
+    GRANITEIO = "graniteio"
+
+class PDLContext():
+    def serialize(self, mode: SerializeMode) -> list[dict[str, Any]]:
+        return []
+
+
+class BaseMessage(PDLContext):
+    message: PdlDict[str, Any]
+
+    def __init__(self, message: dict[str, Any]):
+        if "role" not in message:
+            assert False
+        if "content" not in message:
+            assert False
+        self.message = PdlDict(message)
+
+    def serialize(self, mode: SerializeMode) -> list[dict[str, Any]]:
+        result = self.message.result()
+        return [result]
+
+
+
+class IndependentContext(PDLContext):
+    context: PdlList[PDLContext]
+
+    def __init__(self, context: PdlList[PDLContext]):
+        self.context = context
+
+
+    def serialize(self, mode: SerializeMode) -> list[dict[str, Any]]:
+        result = self.context.result()
+        contexts = [m.serialize(mode) for m in result]
+        flat = [x for xs in contexts for x in xs]
+        if mode == SerializeMode.GRANITEIO:
+            return [{"independent": flat}]
+        return flat
+
+
+class DependentContext(PDLContext):
+    context: PdlList[PDLContext]
+
+    def __init__(self, context: PdlList[PDLContext]):
+        self.context = context
+
+    def serialize(self, mode: SerializeMode) -> list[dict[str, Any]]:
+        result = self.context.result()
+        contexts = [m.serialize(mode) for m in result]
+        return [x for xs in contexts for x in xs]
+    
+
+def deserialize(context: list[dict[str, Any]]) -> DependentContext: # Only support dependent for now 
+    ret: DependentContext = DependentContext(PdlList([]))
+    for message in context:
+        if isinstance(message, dict):
+            if "role" not in message:
+                assert False
+            if "content" not in message:
+                assert False
+            ret = DependentContext(PdlList([ret, BaseMessage(message)]))
+        else:
+            ret = DependentContext(PdlList([ret, message]))
+
+    return ret