lmnr 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

lmnr/cli/cli.py

@@ -4,11 +4,9 @@ import os
 import click
 import logging
 from cookiecutter.main import cookiecutter
-from importlib import resources as importlib_resources
 from pydantic.alias_generators import to_pascal
 
 from .parser.parser import runnable_graph_to_template_vars
-import lmnr
 
 logger = logging.getLogger(__name__)
 
@@ -87,11 +85,10 @@ def pull(pipeline_name, pipeline_version_name, project_api_key, loglevel):
 
     logger.info(f"Context:\n{context}")
     cookiecutter(
-        str(importlib_resources.files(lmnr)),
+        "https://github.com/lmnr-ai/lmnr-python-engine.git",
         output_dir=".",
         config_file=None,
         extra_context=context,
-        directory="cli/",
         no_input=True,
         overwrite_if_exists=True,
     )

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/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/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/cli/parser/nodes/semantic_search.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from datetime import datetime
 
 import uuid
 
@@ -7,44 +6,19 @@ 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]
+    # created_at: datetime
+    # project_id: uuid.UUID
+    # name: str
+    # indexed_on: Optional[str]
 
     @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']}"
-            )
+    def from_dict(cls, dataset_dict: dict) -> "Dataset":
+        return cls(
+            id=uuid.UUID(dataset_dict["id"]),
+        )
 
 
 @dataclass
@@ -57,7 +31,7 @@ class SemanticSearchNode(NodeFunctions):
     limit: int
     threshold: float
     template: str
-    datasources: list[SemanticSearchDatasource]
+    datasets: list[Dataset]
 
     def handles_mapping(
         self, output_handle_id_to_node_name: dict[str, str]
@@ -74,8 +48,6 @@ class SemanticSearchNode(NodeFunctions):
             "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]
-            ),
+            "datasource_ids": [str(dataset.id) for dataset in self.datasets],
+            "datasource_ids_list": str([str(dataset.id) for dataset in self.datasets]),
         }

lmnr/cli/parser/nodes/types.py

@@ -2,11 +2,14 @@ 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,
+    Dataset,
     SemanticSearchNode,
 )
 from lmnr.types import NodeInput, ChatMessage
@@ -21,7 +24,15 @@ def node_input_from_json(json_val: Any) -> NodeInput:
         raise ValueError(f"Invalid NodeInput value: {json_val}")
 
 
-Node = Union[InputNode, OutputNode, LLMNode, SemanticSearchNode]
+Node = Union[
+    InputNode,
+    OutputNode,
+    ConditionNode,
+    LLMNode,
+    RouterNode,
+    SemanticSearchNode,
+    CodeNode,
+]
 
 
 def node_from_dict(node_dict: dict) -> Node:
@@ -44,6 +55,18 @@ def node_from_dict(node_dict: dict) -> Node:
                 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"]),
@@ -69,6 +92,19 @@ def node_from_dict(node_dict: dict) -> Node:
             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"]),
@@ -82,10 +118,18 @@ def node_from_dict(node_dict: dict) -> Node:
             limit=node_dict["limit"],
             threshold=node_dict["threshold"],
             template=node_dict["template"],
-            datasources=[
-                SemanticSearchDatasource.from_dict(ds)
-                for ds in node_dict["datasources"]
-            ],
+            datasets=[Dataset.from_dict(ds) for ds in node_dict["datasets"]],
+        )
+    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/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/sdk/remote_debugger.py

@@ -96,6 +96,7 @@ class RemoteDebugger:
                             f'{tool.__name__}: {e}'
                         e = ToolCallError(error=error_message, reqId=req_id)
                         websocket.send(e.model_dump_json())
+                        continue
                     formatted_response = None
                     try:
                         formatted_response = ToolCallResponse(

lmnr/types.py

@@ -9,7 +9,12 @@ class ChatMessage(pydantic.BaseModel):
     content: str
 
 
-NodeInput = Union[str, list[ChatMessage]]  # TypeAlias
+class ConditionedValue(pydantic.BaseModel):
+    condition: str
+    value: "NodeInput"
+
+
+NodeInput = Union[str, list[ChatMessage], ConditionedValue]  # TypeAlias
 
 
 class EndpointRunRequest(pydantic.BaseModel):
@@ -51,7 +56,7 @@ class SDKError(Exception):
         super().__init__(error_message)
 
 
-class ToolCallRequest(pydantic.BaseModel):
+class ToolCallFunction(pydantic.BaseModel):
     name: str
     arguments: str
 
@@ -59,7 +64,7 @@ class ToolCallRequest(pydantic.BaseModel):
 class ToolCall(pydantic.BaseModel):
     id: Optional[str]
     type: Optional[str]
-    function: ToolCallRequest
+    function: ToolCallFunction
 
 
 # TODO: allow snake_case and manually convert to camelCase

{lmnr-0.2.6.dist-info → lmnr-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lmnr
-Version: 0.2.6
+Version: 0.2.8
 Summary: Python SDK for Laminar AI
 License: Apache-2.0
 Author: lmnr.ai
@@ -22,7 +22,7 @@ Description-Content-Type: text/markdown
 
 # Laminar AI
 
-This reipo provides core for code generation, Laminar CLI, and Laminar SDK.
+This repo provides core for code generation, Laminar CLI, and Laminar SDK.
 
 ## Quickstart
 ```sh
@@ -166,12 +166,12 @@ res = pipeline.run(
         "OPENAI_API_KEY": <OPENAI_API_KEY>,
     }
 )
-print(f"RESULT:\n{res}")
+print(f"Pipeline run result:\n{res}")
 ```
 
 ### Current functionality
-- Supports graph generation for graphs with Input, Output, and LLM nodes only
-- For LLM nodes, it only supports OpenAI and Anthropic models and doesn't support structured output
+- Supports graph generation for graphs with the following nodes: Input, Output, LLM, Router, Code.
+- For LLM nodes, it only supports OpenAI and Anthropic models. Structured output in LLM nodes will be supported soon.
 
 ## PROJECT_API_KEY
 

lmnr-0.2.8.dist-info/RECORD

@@ -0,0 +1,24 @@
+lmnr/__init__.py,sha256=NWHDZ-KAl3pQGDnKUbBbZaW4es-0-9Xt6gP-UrjyuEQ,207
+lmnr/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lmnr/cli/__main__.py,sha256=8hDtWlaFZK24KhfNq_ZKgtXqYHsDQDetukOCMlsbW0Q,59
+lmnr/cli/cli.py,sha256=0Qw_dxE_N9F38asUB7pMbILJGVi-pPtqiao4aTjQQGM,2769
+lmnr/cli/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lmnr/cli/parser/nodes/__init__.py,sha256=BNbbfn0WwbFDA6TNhLOaT_Ji69rCL5voUibqMD7Knng,1163
+lmnr/cli/parser/nodes/code.py,sha256=GXqOxN6tdiStZGWLbN3WZCmDfzwYIgSRmZ5t72AOIXc,661
+lmnr/cli/parser/nodes/condition.py,sha256=AJny0ILXbSy1hTwsRvZvDUqts9INNx63yQSkD7Dp7KU,740
+lmnr/cli/parser/nodes/input.py,sha256=Xwktcih7Mezqv4cEejfPkpG8uJxDsbqRytBvKmlJDYE,578
+lmnr/cli/parser/nodes/llm.py,sha256=iQWYFnQi5PcQD9WJpTSHbSzClM6s0wBOoEqyN5c4yQo,1674
+lmnr/cli/parser/nodes/output.py,sha256=1XBppSscxM01kfZhE9oOh2GgdCVzyPVe2RAxLI5HmUc,665
+lmnr/cli/parser/nodes/router.py,sha256=dmCx4ho8_GdFJXQa8UevMf_uEP7AKBv_MJ2zpLC6Vck,894
+lmnr/cli/parser/nodes/semantic_search.py,sha256=DWDPpV78XZ7vPIaPd86FbeDFAnKah4e61M1TOzwnt84,1352
+lmnr/cli/parser/nodes/types.py,sha256=XJQUg5VTbpc8LKN3-DMZkDMDiweGtKlA05edTcMYbr0,5257
+lmnr/cli/parser/parser.py,sha256=kAZEeg358lyj_Q1IIhQB_bA7LW3Aw6RduShIfUSmLqQ,2173
+lmnr/cli/parser/utils.py,sha256=wVaqHVOR9VXl8Og9nkVyCVgHIcgbtYGkDOEGPtmjZ8g,715
+lmnr/sdk/endpoint.py,sha256=0HjcxMUcJz-klFZO2f5xtTaoLjcaEb8vrJ_YldTWUc8,7467
+lmnr/sdk/remote_debugger.py,sha256=tC8OywEkxzeUCAHrpfhlL-iMP_0Rqh9qC2DtoYEGJjU,5174
+lmnr/types.py,sha256=OR9xRAQ5uTTwpJTDL_e3jZqxYJWvyX96CCoxr3oo94g,2112
+lmnr-0.2.8.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
+lmnr-0.2.8.dist-info/METADATA,sha256=kfHTeQtkFVsk3JK3LopVuvfr5OQkjG0YGXyoRrrqPq4,5479
+lmnr-0.2.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+lmnr-0.2.8.dist-info/entry_points.txt,sha256=Qg7ZRax4k-rcQsZ26XRYQ8YFSBiyY2PNxYfq4a6PYXI,41
+lmnr-0.2.8.dist-info/RECORD,,

lmnr/cli/cookiecutter.json

@@ -1,9 +0,0 @@
-{
-    "lmnr_pipelines_dir_name": "lmnr_engine",
-    "pipeline_name": "Laminar Pipeline",
-    "pipeline_dir_name": "{{ cookiecutter['pipeline_name'].lower().replace('-', '_').replace(' ', '_') }}",
-    "class_name": "LaminarPipeline",
-    "pipeline_version_name": "main",
-    "_tasks": {},
-    "_jinja2_env_vars": {"lstrip_blocks": true, "trim_blocks": true}
-}

lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/__init__.py

@@ -1 +0,0 @@
-from .engine import Engine

lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/action.py

@@ -1,14 +0,0 @@
-from dataclasses import dataclass
-from typing import Union
-
-from lmnr_engine.types import NodeInput
-
-
-@dataclass
-class RunOutput:
-    status: str  # "Success" | "Termination"  TODO: Turn into Enum
-    output: Union[NodeInput, None]
-
-
-class NodeRunError(Exception):
-    pass

lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/engine.py

@@ -1,262 +0,0 @@
-from concurrent.futures import ThreadPoolExecutor
-import datetime
-import logging
-from typing import Optional
-import uuid
-from dataclasses import dataclass
-import queue
-
-from .task import Task
-from .action import NodeRunError, RunOutput
-from .state import State
-from lmnr.types import NodeInput
-from lmnr_engine.types import Message
-
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class ScheduledTask:
-    status: str  # "Task" | "Err"  TODO: Use an enum
-    task_name: Optional[str]
-
-
-class RunError(Exception):
-    outputs: dict[str, Message]
-
-
-@dataclass
-class Engine:
-    tasks: dict[str, Task]
-    active_tasks: set[str]
-    depths: dict[str, int]
-    outputs: dict[str, Message]
-    env: dict[str, str]
-    thread_pool_executor: ThreadPoolExecutor
-    # TODO: Store thread pool executor's Futures here to have control
-    # over them (e.g. cancel them)
-
-    @classmethod
-    def new(
-        cls, thread_pool_executor: ThreadPoolExecutor, env: dict[str, str] = {}
-    ) -> "Engine":
-        return cls(
-            tasks={},
-            active_tasks=set(),
-            depths={},
-            outputs={},
-            env=env,
-            thread_pool_executor=thread_pool_executor,
-        )
-
-    @classmethod
-    def with_tasks(
-        cls,
-        tasks: list[Task],
-        thread_pool_executor: ThreadPoolExecutor,
-        env: dict[str, str] = {},
-    ) -> "Engine":
-        dag = cls.new(thread_pool_executor, env=env)
-
-        for task in tasks:
-            dag.tasks[task.name] = task
-            dag.depths[task.name] = 0
-
-        return dag
-
-    def override_inputs(self, inputs: dict[str, NodeInput]) -> None:
-        for task in self.tasks.values():
-            # TODO: Check that it's the Input type task
-            if not task.prev:
-                task.value = inputs[task.name]
-
-    def run(self, inputs: dict[str, NodeInput]) -> dict[str, Message]:
-        self.override_inputs(inputs)
-
-        q = queue.Queue()
-
-        input_tasks = []
-        for task in self.tasks.values():
-            if len(task.prev) == 0:
-                input_tasks.append(task.name)
-
-        for task_id in input_tasks:
-            q.put(ScheduledTask(status="Task", task_name=task_id))
-
-        while True:
-            logger.info("Waiting for task from queue")
-            scheduled_task: ScheduledTask = q.get()
-            logger.info(f"Got task from queue: {scheduled_task}")
-            if scheduled_task.status == "Err":
-                # TODO: Abort all other threads
-                raise RunError(self.outputs)
-
-            task: Task = self.tasks[scheduled_task.task_name]  # type: ignore
-            logger.info(f"Task next: {task.next}")
-
-            if not task.next:
-                try:
-                    fut = self.execute_task(task, q)
-                    fut.result()
-                    if not self.active_tasks:
-                        return self.outputs
-                except Exception:
-                    raise RunError(self.outputs)
-            else:
-                self.execute_task(task, q)
-
-    def execute_task_inner(
-        self,
-        task: Task,
-        queue: queue.Queue,
-    ) -> None:
-        task_id = task.name
-        next = task.next
-        input_states = task.input_states
-        active_tasks = self.active_tasks
-        tasks = self.tasks
-        depths = self.depths
-        depth = depths[task.name]
-        outputs = self.outputs
-
-        inputs: dict[str, NodeInput] = {}
-        input_messages = []
-
-        # Wait for inputs for this task to be set
-        for handle_name, input_state in input_states.items():
-            logger.info(f"Task {task_id} waiting for semaphore for {handle_name}")
-            input_state.semaphore.acquire()
-            logger.info(f"Task {task_id} acquired semaphore for {handle_name}")
-
-            # Set the outputs of predecessors as inputs of the current
-            output = input_state.get_state()
-            # If at least one of the inputs is termination,
-            # also terminate this task early and set its state to termination
-            if output.status == "Termination":
-                return
-            message = output.get_out()
-
-            inputs[handle_name] = message.value
-            input_messages.append(message)
-
-        start_time = datetime.datetime.now()
-
-        try:
-            if callable(task.value):
-                res = task.value(**inputs, _env=self.env)
-            else:
-                res = RunOutput(status="Success", output=task.value)
-
-            if res.status == "Success":
-                id = uuid.uuid4()
-                state = State.new(
-                    Message(
-                        id=id,
-                        value=res.output,  # type: ignore
-                        start_time=start_time,
-                        end_time=datetime.datetime.now(),
-                    )
-                )
-            else:
-                assert res.status == "Termination"
-                state = State.termination()
-
-            is_termination = state.is_termination()
-            logger.info(f"Task {task_id} executed")
-
-            # remove the task from active tasks once it's done
-            if task_id in active_tasks:
-                active_tasks.remove(task_id)
-
-            if depth > 0:
-                # propagate reset once we enter the loop
-                # TODO: Implement this for cycles
-                raise NotImplementedError()
-
-            if depth == 10:
-                # TODO: Implement this for cycles
-                raise NotImplementedError()
-
-            if not next:
-                # if there are no next tasks, we can terminate the graph
-                outputs[task.name] = state.get_out()
-
-            # push next tasks to the channel only if
-            # the current task is not a termination
-            for next_task_name in next:
-                # we set the inputs of the next tasks
-                # to the outputs of the current task
-                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]
-                    next_state.set_state_and_permits(state, 1)
-
-                # push next tasks to the channel only if the task is not active
-                # and current task is not a termination
-                if not (next_task_name in active_tasks) and not is_termination:
-                    active_tasks.add(next_task_name)
-                    queue.put(
-                        ScheduledTask(
-                            status="Task",
-                            task_name=next_task_name,
-                        )
-                    )
-
-            # increment depth of the finished task
-            depths[task_id] = depth + 1
-        except NodeRunError as e:
-            logger.exception(f"Execution failed [id: {task_id}]")
-
-            error = Message(
-                id=uuid.uuid4(),
-                value=str(e),
-                start_time=start_time,
-                end_time=datetime.datetime.now(),
-            )
-
-            outputs[task.name] = error
-
-            # terminate entire graph by sending err task
-            queue.put(
-                ScheduledTask(
-                    status="Err",
-                    task_name=None,
-                )
-            )
-
-        except Exception:
-            logger.exception(f"Execution failed [id: {task_id}]")
-            error = Message(
-                id=uuid.uuid4(),
-                value="Unexpected server error",
-                start_time=start_time,
-                end_time=datetime.datetime.now(),
-            )
-            outputs[task.name] = error
-            queue.put(
-                ScheduledTask(
-                    status="Err",
-                    task_name=None,
-                )
-            )
-
-    def execute_task(
-        self,
-        task: Task,
-        queue: queue.Queue,
-    ):
-        return self.thread_pool_executor.submit(
-            self.execute_task_inner,
-            task,
-            queue,
-        )

lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/state.py

@@ -1,69 +0,0 @@
-import threading
-from dataclasses import dataclass
-from typing import Union
-
-from lmnr_engine.types import Message
-
-
-@dataclass
-class State:
-    status: str  # "Success", "Empty", "Termination"  # TODO: Turn into Enum
-    message: Union[Message, None]
-
-    @classmethod
-    def new(cls, val: Message) -> "State":
-        return cls(
-            status="Success",
-            message=val,
-        )
-
-    @classmethod
-    def empty(cls) -> "State":
-        return cls(
-            status="Empty",
-            message=Message.empty(),
-        )
-
-    @classmethod
-    def termination(cls) -> "State":
-        return cls(
-            status="Termination",
-            message=None,
-        )
-
-    def is_success(self) -> bool:
-        return self.status == "Success"
-
-    def is_termination(self) -> bool:
-        return self.status == "Termination"
-
-    def get_out(self) -> Message:
-        if self.message is None:
-            raise ValueError("Cannot get message from a termination state")
-
-        return self.message
-
-
-@dataclass
-class ExecState:
-    output: State
-    semaphore: threading.Semaphore
-
-    @classmethod
-    def new(cls) -> "ExecState":
-        return cls(
-            output=State.empty(),
-            semaphore=threading.Semaphore(0),
-        )
-
-    # Assume this is called by the caller who doesn't need to acquire semaphore
-    def set_state(self, output: State):
-        self.output = output
-
-    # Assume the caller is smart to call this after acquiring the semaphore
-    def get_state(self) -> State:
-        return self.output
-
-    def set_state_and_permits(self, output: State, permits: int):
-        self.output = output
-        self.semaphore.release(permits)

lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/task.py

@@ -1,38 +0,0 @@
-from typing import Callable, Union
-
-from .action import RunOutput
-from .state import ExecState
-from lmnr_engine.types import NodeInput
-
-
-class Task:
-    # unique identifier
-    name: str
-    # mapping from current node's handle name to previous node's unique name
-    # assumes nodes have only one output
-    handles_mapping: list[tuple[str, str]]
-    # Value or a function that returns a value
-    # Usually a function which waits for inputs from previous nodes
-    value: Union[NodeInput, Callable[..., RunOutput]]  # TODO: Type this fully
-    # unique node names of previous nodes
-    prev: list[str]
-    # unique node names of next nodes
-    next: list[str]
-    input_states: dict[str, ExecState]
-
-    def __init__(
-        self,
-        name: str,
-        handles_mapping: list[tuple[str, str]],
-        value: Union[NodeInput, Callable[..., RunOutput]],
-        prev: list[str],
-        next: list[str],
-    ) -> None:
-        self.name = name
-        self.handles_mapping = handles_mapping
-        self.value = value
-        self.prev = prev
-        self.next = next
-        self.input_states = {
-            handle_name: ExecState.new() for (handle_name, _) in self.handles_mapping
-        }

lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/pipelines/{{cookiecutter.pipeline_dir_name}}/__init__.py

@@ -1 +0,0 @@
-from .{{ cookiecutter.pipeline_dir_name }} import {{ cookiecutter.class_name }}

lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/pipelines/{{cookiecutter.pipeline_dir_name}}/nodes/functions.py

@@ -1,185 +0,0 @@
-import requests
-import json
-
-from lmnr_engine.engine.action import NodeRunError, RunOutput
-from lmnr_engine.types import ChatMessage, NodeInput
-
-
-{% for task in cookiecutter._tasks.values() %}
-{% if task.node_type == "LLM" %}
-def {{task.function_name}}({{ task.handle_args }}, _env: dict[str, str]) -> RunOutput:
-    {% set chat_messages_found = false %}
-    {% for input_handle_name in task.input_handle_names %}
-    {% if input_handle_name == 'chat_messages' %}
-    {% set chat_messages_found = true %}
-    {% endif %}
-    {% endfor %}
-
-    {% if chat_messages_found %}
-    input_chat_messages = chat_messages
-    {% else %}
-    input_chat_messages = []
-    {% endif %}
-
-    rendered_prompt = """{{task.config.prompt}}"""
-    {% set prompt_variables = task.input_handle_names|reject("equalto", "chat_messages") %}
-    {% for prompt_variable in prompt_variables %}
-    # TODO: Fix this. Using double curly braces in quotes because normal double curly braces
-    # get replaced during rendering by Cookiecutter. This is a hacky solution.
-    rendered_prompt = rendered_prompt.replace("{{'{{'}}{{prompt_variable}}{{'}}'}}", {{prompt_variable}})  # type: ignore
-    {% endfor %}
-
-    {% if task.config.model_params == none %}
-    params = {}
-    {% else %}
-    params = json.loads(
-        """{{task.config.model_params}}"""
-    )
-    {% endif %}
-
-    messages = [ChatMessage(role="system", content=rendered_prompt)]
-    messages.extend(input_chat_messages)
-
-    {% if task.config.provider == "openai" %}
-    message_jsons = [
-        {"role": message.role, "content": message.content} for message in messages
-    ]
-
-    data = {
-        "model": "{{task.config.model}}",
-        "messages": message_jsons,
-    }
-    data.update(params)
-
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {_env['OPENAI_API_KEY']}",
-    }
-    res = requests.post(
-        "https://api.openai.com/v1/chat/completions", json=data, headers=headers
-    )
-
-    if res.status_code != 200:
-        res_json = res.json()
-        raise NodeRunError(f'OpenAI completions request failed: {res_json["error"]["message"]}')
-
-    chat_completion = res.json()
-
-    completion_message = chat_completion["choices"][0]["message"]["content"]
-
-    meta_log = {}
-    meta_log["node_chunk_id"] = None  # TODO: Add node chunk id
-    meta_log["model"] = "{{task.config.model}}"
-    meta_log["prompt"] = rendered_prompt
-    meta_log["input_message_count"] = len(messages)
-    meta_log["input_token_count"] = chat_completion["usage"]["prompt_tokens"]
-    meta_log["output_token_count"] = chat_completion["usage"]["completion_tokens"]
-    meta_log["total_token_count"] = (
-        chat_completion["usage"]["prompt_tokens"] + chat_completion["usage"]["completion_tokens"]
-    )
-    meta_log["approximate_cost"] = None  # TODO: Add approximate cost
-    {% elif task.config.provider == "anthropic" %}
-    data = {
-        "model": "{{task.config.model}}",
-        "max_tokens": 4096,
-    }
-    data.update(params)
-
-    # TODO: Generate appropriate code based on this if-else block
-    if len(messages) == 1 and messages[0].role == "system":
-        messages[0].role = "user"
-        message_jsons = [
-            {"role": message.role, "content": message.content} for message in messages
-        ]
-        data["messages"] = message_jsons
-    else:
-        data["system"] = messages[0].content
-        message_jsons = [
-            {"role": message.role, "content": message.content} for message in messages[1:]
-        ]
-        data["messages"] = message_jsons
-
-    headers = {
-        "Content-Type": "application/json",
-        "X-Api-Key": _env['ANTHROPIC_API_KEY'],
-        "Anthropic-Version": "2023-06-01",
-    }
-    res = requests.post(
-        "https://api.anthropic.com/v1/messages", json=data, headers=headers
-    )
-
-    if res.status_code != 200:
-        raise NodeRunError(f"Anthropic message request failed: {res.text}")
-
-    chat_completion = res.json()
-
-    completion_message = chat_completion["content"][0]["text"]
-
-    meta_log = {}
-    meta_log["node_chunk_id"] = None  # TODO: Add node chunk id
-    meta_log["model"] = "{{task.config.model}}"
-    meta_log["prompt"] = rendered_prompt
-    meta_log["input_message_count"] = len(messages)
-    meta_log["input_token_count"] = chat_completion["usage"]["input_tokens"]
-    meta_log["output_token_count"] = chat_completion["usage"]["output_tokens"]
-    meta_log["total_token_count"] = (
-        chat_completion["usage"]["input_tokens"] + chat_completion["usage"]["output_tokens"]
-    )
-    meta_log["approximate_cost"] = None  # TODO: Add approximate cost
-    {% else %}
-    {% endif %}
-
-    return RunOutput(status="Success", output=completion_message)
-
-
-{% elif task.node_type == "SemanticSearch" %}
-def {{task.function_name}}(query: NodeInput, _env: dict[str, str]) -> RunOutput:
-    {% set datasources_length=task.config.datasource_ids|length %}
-    {% if datasources_length == 0 %}
-    raise NodeRunError("No datasources provided")
-    {% endif %}
-
-    headers = {
-        "Authorization": f"Bearer {_env['LMNR_PROJECT_API_KEY']}",
-    }
-    data = {
-        "query": query,
-        "limit": {{ task.config.limit }},
-        "threshold": {{ task.config.threshold }},
-        "datasourceIds": {{ task.config.datasource_ids_list }},
-    }
-    query_res = requests.post("https://api.lmnr.ai/v2/semantic-search", headers=headers, json=data)
-    if query_res.status_code != 200:
-        raise NodeRunError(f"Vector search request failed: {query_res.text}")
-
-    results = query_res.json()
-
-    def render_query_res_point(template: str, point: dict, relevance_index: int) -> str:
-        data = point["data"]
-        data["relevance_index"] = relevance_index
-        res = template
-        for key, value in data.items():
-            res = res.replace("{{'{{'}}" + key + "{{'}}'}}", str(value))
-        return res
-
-    rendered_res_points = [render_query_res_point("""{{task.config.template}}""", res_point, index + 1) for (index, res_point) in enumerate(results)]
-    output = "\n".join(rendered_res_points)
-
-    return RunOutput(status="Success", output=output)
-
-
-{% elif task.node_type == "Output" %}
-def {{task.function_name}}(output: NodeInput, _env: dict[str, str]) -> RunOutput:
-    return RunOutput(status="Success", output=output)
-
-
-{% elif task.node_type == "Input" %}
-{# Do nothing for Input tasks #}
-{% else %}
-def {{task.function_name}}(output: NodeInput, _env: dict[str, str]) -> RunOutput:
-    return RunOutput(status="Success", output=output)
-
-
-{% endif %}
-{% endfor %}
-# Other functions can be added here

lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/pipelines/{{cookiecutter.pipeline_dir_name}}/{{cookiecutter.pipeline_dir_name}}.py

@@ -1,87 +0,0 @@
-from concurrent.futures import ThreadPoolExecutor
-from dataclasses import dataclass
-import logging
-from typing import Optional, Union
-
-from lmnr.types import ChatMessage
-from lmnr_engine.engine import Engine
-{% set function_names = cookiecutter._tasks.values() | selectattr('node_type', '!=', 'Input') | map(attribute='function_name') | join(', ') %}
-from .nodes.functions import {{ function_names }}
-from lmnr_engine.engine.task import Task
-
-
-logger = logging.getLogger(__name__)
-
-
-class PipelineRunnerError(Exception):
-    pass
-
-
-@dataclass
-class PipelineRunOutput:
-    value: Union[str, list[ChatMessage]]
-
-
-# This class is not imported in other files and can be renamed to desired name
-class {{ cookiecutter.class_name }}:
-    thread_pool_executor: ThreadPoolExecutor
-
-    def __init__(
-        self, thread_pool_executor: Optional[ThreadPoolExecutor] = None
-    ) -> None:
-        # Set max workers to hard-coded value for now
-        self.thread_pool_executor = (
-            ThreadPoolExecutor(max_workers=10)
-            if thread_pool_executor is None
-            else thread_pool_executor
-        )
-
-    def run(
-        self,
-        inputs: dict[str, Union[str, list]],
-        env: dict[str, str] = {},
-    ) -> dict[str, PipelineRunOutput]:
-        """
-        Run the pipeline with the given graph
-
-        Raises:
-            PipelineRunnerError: if there is an error running the pipeline
-        """
-        logger.info("Running pipeline {{ cookiecutter.pipeline_name }}, pipeline_version: {{ cookiecutter.pipeline_version_name }}")
-
-        run_inputs = {}
-        for inp_name, inp in inputs.items():
-            if isinstance(inp, str):
-                run_inputs[inp_name] = inp
-            else:
-                assert isinstance(inp, list), f"Invalid input type: {type(inp)}"
-                run_inputs[inp_name] = [ChatMessage.model_validate(msg) for msg in inp]
-
-        tasks = []
-        {% for task in cookiecutter._tasks.values() %}
-        tasks.append(
-            Task(
-                name="{{ task.name }}",
-                value={{ "''" if task.node_type == "Input" else task.function_name }},
-                handles_mapping={{ task.handles_mapping }},
-                prev=[
-                    {% for prev in task.prev %}
-                    "{{ prev }}",
-                    {% endfor %}
-                ],
-                next=[
-                    {% for next in task.next %}
-                    "{{ next }}",
-                    {% endfor %}
-                ],
-            )
-        )
-        {% endfor %}
-        engine = Engine.with_tasks(tasks, self.thread_pool_executor, env=env)
-
-        # TODO: Raise PipelineRunnerError with node_errors
-        run_res = engine.run(run_inputs)
-        return {
-            name: PipelineRunOutput(value=output.value)
-            for name, output in run_res.items()
-        }

lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/types.py

@@ -1,35 +0,0 @@
-from dataclasses import dataclass
-from typing import Union
-import uuid
-import datetime
-from lmnr.types import NodeInput, ChatMessage
-
-
-@dataclass
-class Message:
-    id: uuid.UUID
-    # output value of producing node in form of NodeInput
-    # for the following consumer
-    value: NodeInput
-    # all input messages to this node; accumulates previous messages too
-    # input_messages: list["Message"]
-    start_time: datetime.datetime
-    end_time: datetime.datetime
-    # node_id: uuid.UUID
-    # node_name: str
-    # node_type: str
-    # all node per-run metadata that needs to be logged at the end of execution
-    # meta_log: MetaLog | None
-
-    @classmethod
-    def empty(cls) -> "Message":
-        return cls(
-            id=uuid.uuid4(),
-            value="",
-            # input_messages=[],
-            start_time=datetime.datetime.now(),
-            end_time=datetime.datetime.now(),
-            # node_id=uuid.uuid4(),
-            # node_name="",
-            # node_type="",
-        )

lmnr-0.2.6.dist-info/RECORD

@@ -1,32 +0,0 @@
-lmnr/__init__.py,sha256=NWHDZ-KAl3pQGDnKUbBbZaW4es-0-9Xt6gP-UrjyuEQ,207
-lmnr/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lmnr/cli/__main__.py,sha256=8hDtWlaFZK24KhfNq_ZKgtXqYHsDQDetukOCMlsbW0Q,59
-lmnr/cli/cli.py,sha256=pzr5LUILi7TcaJIkC-CzmT7RG7-HWApQmUpgK9bc7mI,2847
-lmnr/cli/cookiecutter.json,sha256=PeiMMzCPzDhsapqYoAceYGPI5lOUNimvFzh5KeQv5QE,359
-lmnr/cli/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lmnr/cli/parser/nodes/__init__.py,sha256=BNbbfn0WwbFDA6TNhLOaT_Ji69rCL5voUibqMD7Knng,1163
-lmnr/cli/parser/nodes/input.py,sha256=Xwktcih7Mezqv4cEejfPkpG8uJxDsbqRytBvKmlJDYE,578
-lmnr/cli/parser/nodes/llm.py,sha256=iQWYFnQi5PcQD9WJpTSHbSzClM6s0wBOoEqyN5c4yQo,1674
-lmnr/cli/parser/nodes/output.py,sha256=1XBppSscxM01kfZhE9oOh2GgdCVzyPVe2RAxLI5HmUc,665
-lmnr/cli/parser/nodes/semantic_search.py,sha256=o_XCR7BShAq8VGeKjPTwL6MxLdB07XHSd5CE71sFFiY,2105
-lmnr/cli/parser/nodes/types.py,sha256=c7jNaR7YlZUkxB9OosAkFH4o6ZPga0Bec1WtOxq9fGs,3505
-lmnr/cli/parser/parser.py,sha256=UtuupKj2Dh-47HVcYU4PI2s4Erh1gTjKiuGCcc-nkbM,2163
-lmnr/cli/parser/utils.py,sha256=wVaqHVOR9VXl8Og9nkVyCVgHIcgbtYGkDOEGPtmjZ8g,715
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/__init__.py,sha256=pLVZqvDnNf9foGR-HXnX2F7WC2TWmyCTNcUctG8SXAI,27
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/action.py,sha256=mZMQwwPV5LtSfwdwQ7HefI3ttvwuokp4mhVI_Xn1Zck,274
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/engine.py,sha256=TKmgfXbs_BiuMpzHuPuSfq1mX3UEnQFnpKgU2NsYkB4,8397
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/state.py,sha256=wTx7jAv7b63-8k34cYfQp_DJxhCCOYT_qRHkmnZfnc0,1686
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/task.py,sha256=ware5VIrZvluHH3mpH6h7G0YDk5L0buSQ7s09za4Fro,1200
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/pipelines/{{cookiecutter.pipeline_dir_name}}/__init__.py,sha256=bsfbNUBYtKv37qzc_GLhSAzBam2lnowP_dlr8pubhcg,80
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/pipelines/{{cookiecutter.pipeline_dir_name}}/nodes/functions.py,sha256=HwK6gKngZi1AhEyu9BVtE5IfD4NScRCdFLXV8uiBD34,6578
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/pipelines/{{cookiecutter.pipeline_dir_name}}/{{cookiecutter.pipeline_dir_name}}.py,sha256=WG-ZMofPpGXCx5jdWVry3_XBzcKjqn8ZycFSiWEOBPg,2858
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/types.py,sha256=iWuflMV7TiaBPs6-B-BlrovvWpZgHGGHK0v8rSqER7A,997
-lmnr/sdk/endpoint.py,sha256=0HjcxMUcJz-klFZO2f5xtTaoLjcaEb8vrJ_YldTWUc8,7467
-lmnr/sdk/remote_debugger.py,sha256=vCpMz7y3uboOi81qEwr8z3fhQ2H1y2YtJAxXVtb6uCA,5141
-lmnr/types.py,sha256=IcoKNL1KJ-GIeunrt5fYuB_XhsBrtYZ9d1ShFJqrsUc,2004
-lmnr-0.2.6.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
-lmnr-0.2.6.dist-info/METADATA,sha256=wipVETWwLYjuhdrOpkgUA7iE-kpj5lGph4X7zE0tLvQ,5428
-lmnr-0.2.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-lmnr-0.2.6.dist-info/entry_points.txt,sha256=Qg7ZRax4k-rcQsZ26XRYQ8YFSBiyY2PNxYfq4a6PYXI,41
-lmnr-0.2.6.dist-info/RECORD,,