lmnr 0.2.8__tar.gz → 0.2.9__tar.gz

{lmnr-0.2.8 → lmnr-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lmnr
-Version: 0.2.8
+Version: 0.2.9
 Summary: Python SDK for Laminar AI
 License: Apache-2.0
 Author: lmnr.ai
@@ -14,7 +14,9 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: black (>=24.4.2,<25.0.0)
 Requires-Dist: click (>=8.1.7,<9.0.0)
 Requires-Dist: cookiecutter (>=2.6.0,<3.0.0)
+Requires-Dist: lmnr-baml (>=0.40.0,<0.41.0)
 Requires-Dist: pydantic (>=2.7.4,<3.0.0)
+Requires-Dist: pystache (>=0.6.5,<0.7.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: websockets (>=12.0,<13.0)

{lmnr-0.2.8 → lmnr-0.2.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lmnr"
-version = "0.2.8"
+version = "0.2.9"
 description = "Python SDK for Laminar AI"
 authors = [
   { name = "lmnr.ai", email = "founders@lmnr.ai" }
@@ -11,7 +11,7 @@ license = "Apache-2.0"
 
 [tool.poetry]
 name = "lmnr"
-version = "0.2.8"
+version = "0.2.9"
 description = "Python SDK for Laminar AI"
 authors = ["lmnr.ai"]
 readme = "README.md"
@@ -26,6 +26,8 @@ requests = "^2.32.3"
 websockets = "^12.0"
 cookiecutter = "^2.6.0"
 python-dotenv = "^1.0.1"
+pystache = "^0.6.5"
+lmnr-baml = "^0.40.0"
 
 [build-system]
 requires = ["poetry-core"]

{lmnr-0.2.8 → lmnr-0.2.9}/src/lmnr/cli/parser/nodes/__init__.py

@@ -4,21 +4,16 @@ from typing import Optional
 import uuid
 
 
-HandleType = str  # "String" | "ChatMessageList" | "Any"
-
-
 @dataclass
 class Handle:
     id: uuid.UUID
     name: Optional[str]
-    type: HandleType
 
     @classmethod
     def from_dict(cls, dict: dict) -> "Handle":
         return cls(
             id=uuid.UUID(dict["id"]),
             name=(dict["name"] if "name" in dict else None),
-            type=dict["type"],
         )
 
 

lmnr-0.2.9/src/lmnr/cli/parser/nodes/code.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, NodeFunctions
+from lmnr.cli.parser.utils import map_handles
+
+
+@dataclass
+class CodeNode(NodeFunctions):
+    id: uuid.UUID
+    name: str
+    inputs: list[Handle]
+    outputs: list[Handle]
+    inputs_mappings: dict[uuid.UUID, uuid.UUID]
+    code: str
+    fn_name: str
+
+    def handles_mapping(
+        self, output_handle_id_to_node_name: dict[str, str]
+    ) -> list[tuple[str, str]]:
+        return map_handles(
+            self.inputs, self.inputs_mappings, output_handle_id_to_node_name
+        )
+
+    def node_type(self) -> str:
+        return "Code"
+
+    def config(self) -> dict:
+        return {
+            "code": self.code,
+            "fn_name": self.fn_name,
+            "fn_inputs": ", ".join(
+                f"{handle.name}=input_to_code_node_arg({handle.name})"
+                for handle in self.inputs
+            ),
+        }

{lmnr-0.2.8 → lmnr-0.2.9}/src/lmnr/cli/parser/nodes/input.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from typing import Optional
 import uuid
 
-from lmnr.cli.parser.nodes import Handle, HandleType, NodeFunctions
+from lmnr.cli.parser.nodes import Handle, NodeFunctions
 from lmnr.types import NodeInput
 
 
@@ -12,7 +12,6 @@ class InputNode(NodeFunctions):
     name: str
     outputs: list[Handle]
     input: Optional[NodeInput]
-    input_type: HandleType
 
     def handles_mapping(
         self, output_handle_id_to_node_name: dict[str, str]

lmnr-0.2.8/src/lmnr/cli/parser/nodes/code.py → lmnr-0.2.9/src/lmnr/cli/parser/nodes/json_extractor.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+
 import uuid
 
 from lmnr.cli.parser.nodes import Handle, NodeFunctions
@@ -6,12 +7,13 @@ from lmnr.cli.parser.utils import map_handles
 
 
 @dataclass
-class CodeNode(NodeFunctions):
+class JsonExtractorNode(NodeFunctions):
     id: uuid.UUID
     name: str
     inputs: list[Handle]
     outputs: list[Handle]
     inputs_mappings: dict[uuid.UUID, uuid.UUID]
+    template: str
 
     def handles_mapping(
         self, output_handle_id_to_node_name: dict[str, str]
@@ -21,7 +23,7 @@ class CodeNode(NodeFunctions):
         )
 
     def node_type(self) -> str:
-        return "Code"
+        return "JsonExtractor"
 
     def config(self) -> dict:
-        return {}
+        return {"template": self.template}

{lmnr-0.2.8 → lmnr-0.2.9}/src/lmnr/cli/parser/nodes/llm.py

@@ -44,8 +44,13 @@ class LLMNode(NodeFunctions):
             "model": model,
             "model_params": self.model_params,
             "stream": self.stream,
-            "structured_output_enabled": self.structured_output_enabled,
+            "enable_structured_output": self.structured_output_enabled
+            and self.structured_output_schema is not None,
             "structured_output_max_retries": self.structured_output_max_retries,
             "structured_output_schema": self.structured_output_schema,
-            "structured_output_schema_target": self.structured_output_schema_target,
+            "structured_output_schema_target_str": (
+                "None"
+                if self.structured_output_schema_target is None
+                else f'"{self.structured_output_schema_target}"'
+            ),
         }

{lmnr-0.2.8 → lmnr-0.2.9}/src/lmnr/cli/parser/nodes/types.py

@@ -5,6 +5,7 @@ from lmnr.cli.parser.nodes import Handle
 from lmnr.cli.parser.nodes.code import CodeNode
 from lmnr.cli.parser.nodes.condition import ConditionNode
 from lmnr.cli.parser.nodes.input import InputNode
+from lmnr.cli.parser.nodes.json_extractor import JsonExtractorNode
 from lmnr.cli.parser.nodes.llm import LLMNode
 from lmnr.cli.parser.nodes.output import OutputNode
 from lmnr.cli.parser.nodes.router import Route, RouterNode
@@ -32,6 +33,7 @@ Node = Union[
     RouterNode,
     SemanticSearchNode,
     CodeNode,
+    JsonExtractorNode,
 ]
 
 
@@ -42,7 +44,6 @@ def node_from_dict(node_dict: dict) -> Node:
             name=node_dict["name"],
             outputs=[Handle.from_dict(handle) for handle in node_dict["outputs"]],
             input=node_input_from_json(node_dict["input"]),
-            input_type=node_dict["inputType"],
         )
     elif node_dict["type"] == "Output":
         return OutputNode(
@@ -86,11 +87,14 @@ def node_from_dict(node_dict: dict) -> Node:
                 node_dict["modelParams"] if "modelParams" in node_dict else None
             ),
             stream=False,
-            # TODO: Implement structured output
-            structured_output_enabled=False,
-            structured_output_max_retries=3,
-            structured_output_schema=None,
-            structured_output_schema_target=None,
+            structured_output_enabled=node_dict.get("structuredOutputEnabled", False),
+            structured_output_max_retries=node_dict.get(
+                "structuredOutputMaxRetries", 0
+            ),
+            structured_output_schema=node_dict.get("structuredOutputSchema", None),
+            structured_output_schema_target=node_dict.get(
+                "structuredOutputSchemaTarget", None
+            ),
         )
     elif node_dict["type"] == "Router":
         return RouterNode(
@@ -130,6 +134,20 @@ def node_from_dict(node_dict: dict) -> Node:
                 uuid.UUID(k): uuid.UUID(v)
                 for k, v in node_dict["inputsMappings"].items()
             },
+            code=node_dict["code"],
+            fn_name=node_dict["fnName"],
+        )
+    elif node_dict["type"] == "JsonExtractor":
+        return JsonExtractorNode(
+            id=uuid.UUID(node_dict["id"]),
+            name=node_dict["name"],
+            inputs=[Handle.from_dict(handle) for handle in node_dict["inputs"]],
+            outputs=[Handle.from_dict(handle) for handle in node_dict["outputs"]],
+            inputs_mappings={
+                uuid.UUID(k): uuid.UUID(v)
+                for k, v in node_dict["inputsMappings"].items()
+            },
+            template=node_dict["template"],
         )
     else:
         raise ValueError(f"Node type {node_dict['type']} not supported")

{lmnr-0.2.8 → lmnr-0.2.9}/src/lmnr/cli/parser/parser.py

@@ -1,3 +1,4 @@
+from lmnr.cli.parser.utils import replace_spaces_with_underscores
 from .nodes.types import node_from_dict
 
 
@@ -8,6 +9,9 @@ def runnable_graph_to_template_vars(graph: dict) -> dict:
     node_id_to_node_name = {}
     output_handle_id_to_node_name: dict[str, str] = {}
     for node in graph["nodes"].values():
+        # override node names in the graph itself to be safe
+        node["name"] = replace_spaces_with_underscores(node["name"])
+
         node_id_to_node_name[node["id"]] = node["name"]
         for handle in node["outputs"]:
             output_handle_id_to_node_name[handle["id"]] = node["name"]

{lmnr-0.2.8 → lmnr-0.2.9}/src/lmnr/cli/parser/utils.py

@@ -23,3 +23,27 @@ def map_handles(
         (input_name, output_handle_id_to_node_name[str(output_id)])
         for input_name, output_id in mapping
     ]
+
+
+def replace_spaces_with_underscores(s: str):
+    spaces = [
+        "\u0020",
+        "\u00A0",
+        "\u1680",
+        "\u2000",
+        "\u2001",
+        "\u2002",
+        "\u2003",
+        "\u2004",
+        "\u2005",
+        "\u2006",
+        "\u2007",
+        "\u2008",
+        "\u2009",
+        "\u200A",
+        "\u200B",
+        "\u202F",
+        "\u205F",
+        "\u3000",
+    ]
+    return s.translate({ord(space): "_" for space in spaces})