lmnr 0.2.7__tar.gz → 0.2.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lmnr
-Version: 0.2.7
+Version: 0.2.8
 Summary: Python SDK for Laminar AI
 License: Apache-2.0
 Author: lmnr.ai
@@ -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.7 → lmnr-0.2.8}/README.md

@@ -144,12 +144,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.7 → lmnr-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lmnr"
-version = "0.2.7"
+version = "0.2.8"
 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.7"
+version = "0.2.8"
 description = "Python SDK for Laminar AI"
 authors = ["lmnr.ai"]
 readme = "README.md"

{lmnr-0.2.7 → lmnr-0.2.8}/src/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-0.2.8/src/lmnr/cli/parser/nodes/semantic_search.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass
+
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, NodeFunctions
+from lmnr.cli.parser.utils import map_handles
+
+
+@dataclass
+class Dataset:
+    id: uuid.UUID
+    # created_at: datetime
+    # project_id: uuid.UUID
+    # name: str
+    # indexed_on: Optional[str]
+
+    @classmethod
+    def from_dict(cls, dataset_dict: dict) -> "Dataset":
+        return cls(
+            id=uuid.UUID(dataset_dict["id"]),
+        )
+
+
+@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
+    datasets: list[Dataset]
+
+    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(dataset.id) for dataset in self.datasets],
+            "datasource_ids_list": str([str(dataset.id) for dataset in self.datasets]),
+        }

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

@@ -9,7 +9,7 @@ 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
@@ -118,10 +118,7 @@ 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(

{lmnr-0.2.7 → lmnr-0.2.8}/src/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-0.2.7/src/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-0.2.7/src/lmnr/cli/parser/nodes/semantic_search.py

@@ -1,81 +0,0 @@
-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/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/__init__.py

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

lmnr-0.2.7/src/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-0.2.7/src/lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/engine.py

@@ -1,293 +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:
-                self.propagate_reset(task_id, task_id, tasks)
-
-            # terminate graph on recursion depth exceeding 10
-            if depth == 10:
-                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
-                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,
-        )
-
-    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)

lmnr-0.2.7/src/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-0.2.7/src/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-0.2.7/src/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-0.2.7/src/lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/pipelines/{{cookiecutter.pipeline_dir_name}}/nodes/functions.py

@@ -1,221 +0,0 @@
-import requests
-import json
-
-from lmnr.types import ConditionedValue
-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 = {}
-    {# TODO: Add node chunk id #}
-    meta_log["node_chunk_id"] = None
-    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"]
-    )
-    {# TODO: Add approximate cost #}
-    meta_log["approximate_cost"] = None
-    {% 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 = {}
-    {# TODO: Add node chunk id#}
-    meta_log["node_chunk_id"] = None
-    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"]
-    )
-    {# TODO: Add approximate cost#}
-    meta_log["approximate_cost"] = None
-    {% 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.status_code}\n{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 == "Router" %}
-def {{task.function_name}}(condition: NodeInput, input: NodeInput, _env: dict[str, str]) -> RunOutput:
-    routes = {{ task.config.routes }}
-    has_default_route = {{ task.config.has_default_route }}
-
-    for route in routes:
-        if route == condition:
-            return RunOutput(status="Success", output=ConditionedValue(condition=route, value=input))
-        
-    if has_default_route:
-        return RunOutput(status="Success", output=ConditionedValue(condition=routes[-1], value=input))
-
-    raise NodeRunError(f"No route found for condition {condition}")
-
-
-{% elif task.node_type == "Condition" %}
-def {{task.function_name}}(input: NodeInput, _env: dict[str, str]) -> RunOutput:
-    condition = "{{task.config.condition}}"
-
-    if input.condition == condition:
-        return RunOutput(status="Success", output=input.value)
-    else:
-        return RunOutput(status="Termination", output=None)
-
-
-{% elif task.node_type == "Code" %}
-def {{task.function_name}}({{ task.handle_args }}, _env: dict[str, str]) -> RunOutput:
-    # Implement any functionality you want here
-    raise NodeRunError("Implement your code here")
-
-
-{% 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-0.2.7/src/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-0.2.7/src/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="",
-        )