lmnr 0.2.5__tar.gz → 0.2.7__tar.gz

{lmnr-0.2.5 → lmnr-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lmnr
-Version: 0.2.5
+Version: 0.2.7
 Summary: Python SDK for Laminar AI
 License: Apache-2.0
 Author: lmnr.ai
@@ -17,11 +17,12 @@ Requires-Dist: cookiecutter (>=2.6.0,<3.0.0)
 Requires-Dist: pydantic (>=2.7.4,<3.0.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: urllib3 (==1.26.6)
 Requires-Dist: websockets (>=12.0,<13.0)
 Description-Content-Type: text/markdown
 
-# Python SDK for Laminar AI
+# Laminar AI
+
+This repo provides core for code generation, Laminar CLI, and Laminar SDK.
 
 ## Quickstart
 ```sh
@@ -139,14 +140,6 @@ Set up `DEBUGGER_SESSION_ID` environment variable in your pipeline.
 
 You can run as many sessions as you need, experimenting with your flows.
 
-#### 5. Stop the debugger
-
-In order to stop the session, do
-
-```python
-debugger.stop()
-```
-
 ## CLI for code generation
 
 ### Basic usage

{lmnr-0.2.5 → lmnr-0.2.7}/README.md

@@ -1,4 +1,6 @@
-# Python SDK for Laminar AI
+# Laminar AI
+
+This repo provides core for code generation, Laminar CLI, and Laminar SDK.
 
 ## Quickstart
 ```sh
@@ -116,14 +118,6 @@ Set up `DEBUGGER_SESSION_ID` environment variable in your pipeline.
 
 You can run as many sessions as you need, experimenting with your flows.
 
-#### 5. Stop the debugger
-
-In order to stop the session, do
-
-```python
-debugger.stop()
-```
-
 ## CLI for code generation
 
 ### Basic usage

{lmnr-0.2.5 → lmnr-0.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lmnr"
-version = "0.2.5"
+version = "0.2.7"
 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.5"
+version = "0.2.7"
 description = "Python SDK for Laminar AI"
 authors = ["lmnr.ai"]
 readme = "README.md"
@@ -23,7 +23,6 @@ black = "^24.4.2"
 pydantic = "^2.7.4"
 click = "^8.1.7"
 requests = "^2.32.3"
-urllib3 = "1.26.6"
 websockets = "^12.0"
 cookiecutter = "^2.6.0"
 python-dotenv = "^1.0.1"

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

@@ -0,0 +1,27 @@
+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]
+
+    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 {}

lmnr-0.2.7/src/lmnr/cli/parser/nodes/condition.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, NodeFunctions
+from lmnr.cli.parser.utils import map_handles
+
+
+@dataclass
+class ConditionNode(NodeFunctions):
+    id: uuid.UUID
+    name: str
+    inputs: list[Handle]
+    outputs: list[Handle]
+    inputs_mappings: dict[uuid.UUID, uuid.UUID]
+    condition: 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 "Condition"
+
+    def config(self) -> dict:
+        return {
+            "condition": self.condition,
+        }

lmnr-0.2.7/src/lmnr/cli/parser/nodes/input.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+from typing import Optional
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, HandleType, NodeFunctions
+from lmnr.types import NodeInput
+
+
+@dataclass
+class InputNode(NodeFunctions):
+    id: uuid.UUID
+    name: str
+    outputs: list[Handle]
+    input: Optional[NodeInput]
+    input_type: HandleType
+
+    def handles_mapping(
+        self, output_handle_id_to_node_name: dict[str, str]
+    ) -> list[tuple[str, str]]:
+        return []
+
+    def node_type(self) -> str:
+        return "Input"
+
+    def config(self) -> dict:
+        return {}

lmnr-0.2.7/src/lmnr/cli/parser/nodes/llm.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+from typing import Optional
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, NodeFunctions
+from lmnr.cli.parser.utils import map_handles
+
+
+@dataclass
+class LLMNode(NodeFunctions):
+    id: uuid.UUID
+    name: str
+    inputs: list[Handle]
+    dynamic_inputs: list[Handle]
+    outputs: list[Handle]
+    inputs_mappings: dict[uuid.UUID, uuid.UUID]
+    prompt: str
+    model: str
+    model_params: Optional[str]
+    stream: bool
+    structured_output_enabled: bool
+    structured_output_max_retries: int
+    structured_output_schema: Optional[str]
+    structured_output_schema_target: Optional[str]
+
+    def handles_mapping(
+        self, output_handle_id_to_node_name: dict[str, str]
+    ) -> list[tuple[str, str]]:
+        combined_inputs = self.inputs + self.dynamic_inputs
+        return map_handles(
+            combined_inputs, self.inputs_mappings, output_handle_id_to_node_name
+        )
+
+    def node_type(self) -> str:
+        return "LLM"
+
+    def config(self) -> dict:
+        # For easier access in the template separate the provider and model here
+        provider, model = self.model.split(":", maxsplit=1)
+
+        return {
+            "prompt": self.prompt,
+            "provider": provider,
+            "model": model,
+            "model_params": self.model_params,
+            "stream": self.stream,
+            "structured_output_enabled": self.structured_output_enabled,
+            "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,
+        }

lmnr-0.2.7/src/lmnr/cli/parser/nodes/output.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, NodeFunctions
+from lmnr.cli.parser.utils import map_handles
+
+
+@dataclass
+class OutputNode(NodeFunctions):
+    id: uuid.UUID
+    name: str
+    inputs: list[Handle]
+    outputs: list[Handle]
+    inputs_mappings: dict[uuid.UUID, uuid.UUID]
+
+    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 "Output"
+
+    def config(self) -> dict:
+        return {}

lmnr-0.2.7/src/lmnr/cli/parser/nodes/router.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, NodeFunctions
+from lmnr.cli.parser.utils import map_handles
+
+
+@dataclass
+class Route:
+    name: str
+
+
+@dataclass
+class RouterNode(NodeFunctions):
+    id: uuid.UUID
+    name: str
+    inputs: list[Handle]
+    outputs: list[Handle]
+    inputs_mappings: dict[uuid.UUID, uuid.UUID]
+    routes: list[Route]
+    has_default_route: bool
+
+    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 "Router"
+
+    def config(self) -> dict:
+        return {
+            "routes": str([route.name for route in self.routes]),
+            "has_default_route": str(self.has_default_route),
+        }

lmnr-0.2.7/src/lmnr/cli/parser/nodes/semantic_search.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass
+from datetime import datetime
+
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, NodeFunctions
+from lmnr.cli.parser.utils import map_handles
+
+
+@dataclass
+class FileMetadata:
+    id: uuid.UUID
+    created_at: datetime
+    project_id: uuid.UUID
+    filename: str
+
+
+@dataclass
+class Dataset:
+    id: uuid.UUID
+    created_at: datetime
+    project_id: uuid.UUID
+    name: str
+
+
+@dataclass
+class SemanticSearchDatasource:
+    type: str
+    id: uuid.UUID
+    # TODO: Paste other fields here, use Union[FileMetadata, Dataset]
+
+    @classmethod
+    def from_dict(cls, datasource_dict: dict) -> "SemanticSearchDatasource":
+        if datasource_dict["type"] == "File":
+            return cls(
+                type="File",
+                id=uuid.UUID(datasource_dict["id"]),
+            )
+        elif datasource_dict["type"] == "Dataset":
+            return cls(
+                type="Dataset",
+                id=uuid.UUID(datasource_dict["id"]),
+            )
+        else:
+            raise ValueError(
+                f"Invalid SemanticSearchDatasource type: {datasource_dict['type']}"
+            )
+
+
+@dataclass
+class SemanticSearchNode(NodeFunctions):
+    id: uuid.UUID
+    name: str
+    inputs: list[Handle]
+    outputs: list[Handle]
+    inputs_mappings: dict[uuid.UUID, uuid.UUID]
+    limit: int
+    threshold: float
+    template: str
+    datasources: list[SemanticSearchDatasource]
+
+    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 "SemanticSearch"
+
+    def config(self) -> dict:
+        return {
+            "limit": self.limit,
+            "threshold": self.threshold,
+            "template": self.template,
+            "datasource_ids": [str(datasource.id) for datasource in self.datasources],
+            "datasource_ids_list": str(
+                [str(datasource.id) for datasource in self.datasources]
+            ),
+        }

lmnr-0.2.7/src/lmnr/cli/parser/nodes/types.py

@@ -0,0 +1,138 @@
+from typing import Any, Union
+import uuid
+
+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.llm import LLMNode
+from lmnr.cli.parser.nodes.output import OutputNode
+from lmnr.cli.parser.nodes.router import Route, RouterNode
+from lmnr.cli.parser.nodes.semantic_search import (
+    SemanticSearchDatasource,
+    SemanticSearchNode,
+)
+from lmnr.types import NodeInput, ChatMessage
+
+
+def node_input_from_json(json_val: Any) -> NodeInput:
+    if isinstance(json_val, str):
+        return json_val
+    elif isinstance(json_val, list):
+        return [ChatMessage.model_validate(msg) for msg in json_val]
+    else:
+        raise ValueError(f"Invalid NodeInput value: {json_val}")
+
+
+Node = Union[
+    InputNode,
+    OutputNode,
+    ConditionNode,
+    LLMNode,
+    RouterNode,
+    SemanticSearchNode,
+    CodeNode,
+]
+
+
+def node_from_dict(node_dict: dict) -> Node:
+    if node_dict["type"] == "Input":
+        return InputNode(
+            id=uuid.UUID(node_dict["id"]),
+            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(
+            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()
+            },
+        )
+    elif node_dict["type"] == "Condition":
+        return ConditionNode(
+            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()
+            },
+            condition=node_dict["condition"],
+        )
+    elif node_dict["type"] == "LLM":
+        return LLMNode(
+            id=uuid.UUID(node_dict["id"]),
+            name=node_dict["name"],
+            inputs=[Handle.from_dict(handle) for handle in node_dict["inputs"]],
+            dynamic_inputs=[
+                Handle.from_dict(handle) for handle in node_dict["dynamicInputs"]
+            ],
+            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()
+            },
+            prompt=node_dict["prompt"],
+            model=node_dict["model"],
+            model_params=(
+                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,
+        )
+    elif node_dict["type"] == "Router":
+        return RouterNode(
+            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()
+            },
+            routes=[Route(name=route["name"]) for route in node_dict["routes"]],
+            has_default_route=node_dict["hasDefaultRoute"],
+        )
+    elif node_dict["type"] == "SemanticSearch":
+        return SemanticSearchNode(
+            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()
+            },
+            limit=node_dict["limit"],
+            threshold=node_dict["threshold"],
+            template=node_dict["template"],
+            datasources=[
+                SemanticSearchDatasource.from_dict(ds)
+                for ds in node_dict["datasources"]
+            ],
+        )
+    elif node_dict["type"] == "Code":
+        return CodeNode(
+            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()
+            },
+        )
+    else:
+        raise ValueError(f"Node type {node_dict['type']} not supported")

{lmnr-0.2.5 → lmnr-0.2.7}/src/lmnr/cli/parser/parser.py

@@ -17,6 +17,9 @@ def runnable_graph_to_template_vars(graph: dict) -> dict:
         node = node_from_dict(node_obj)
         handles_mapping = node.handles_mapping(output_handle_id_to_node_name)
         node_type = node.node_type()
+
+        unique_handles = set([handle_name for (handle_name, _) in handles_mapping])
+
         tasks.append(
             {
                 "name": node.name,
@@ -28,10 +31,7 @@ def runnable_graph_to_template_vars(graph: dict) -> dict:
                     handle_name for (handle_name, _) in handles_mapping
                 ],
                 "handle_args": ", ".join(
-                    [
-                        f"{handle_name}: NodeInput"
-                        for (handle_name, _) in handles_mapping
-                    ]
+                    [f"{handle_name}: NodeInput" for handle_name in unique_handles]
                 ),
                 "prev": [],
                 "next": [],

{lmnr-0.2.5 → lmnr-0.2.7}/src/lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/engine.py

@@ -9,7 +9,8 @@ import queue
 from .task import Task
 from .action import NodeRunError, RunOutput
 from .state import State
-from lmnr_engine.types import Message, NodeInput
+from lmnr.types import NodeInput
+from lmnr_engine.types import Message
 
 
 logger = logging.getLogger(__name__)
@@ -169,13 +170,17 @@ class Engine:
                 active_tasks.remove(task_id)
 
             if depth > 0:
-                # propagate reset once we enter the loop
-                # TODO: Implement this for cycles
-                raise NotImplementedError()
+                self.propagate_reset(task_id, task_id, tasks)
 
+            # terminate graph on recursion depth exceeding 10
             if depth == 10:
-                # TODO: Implement this for cycles
-                raise NotImplementedError()
+                logging.error("Max recursion depth exceeded, terminating graph")
+                error = Message(
+                    id=uuid.uuid4(),
+                    value="Max recursion depth exceeded",
+                    start_time=start_time,
+                    end_time=datetime.datetime.now(),
+                )
 
             if not next:
                 # if there are no next tasks, we can terminate the graph
@@ -259,3 +264,30 @@ class Engine:
             task,
             queue,
         )
+
+    def propagate_reset(
+        self, current_task_name: str, start_task_name: str, tasks: dict[str, Task]
+    ) -> None:
+        task = tasks[current_task_name]
+
+        for next_task_name in task.next:
+            if next_task_name == start_task_name:
+                return
+
+            next_task = tasks[next_task_name]
+
+            # in majority of cases there will be only one handle name
+            # however we need to handle the case when single output is mapped
+            # to multiple inputs on the next node
+            handle_names = []
+            for k, v in next_task.handles_mapping:
+                if v == task.name:
+                    handle_names.append(k)
+
+            for handle_name in handle_names:
+                next_state = next_task.input_states[handle_name]
+
+                if next_state.get_state().is_success():
+                    next_state.set_state(State.empty())
+                    next_state.semaphore.release()
+                    self.propagate_reset(next_task_name, start_task_name, tasks)