lmnr 0.2.14__py3-none-any.whl → 0.3.0b1__py3-none-any.whl

lmnr/cli/parser/nodes/output.py

@@ -1,27 +0,0 @@
-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/cli/parser/nodes/router.py

@@ -1,37 +0,0 @@
-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,53 +0,0 @@
-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/cli/parser/nodes/types.py

@@ -1,153 +0,0 @@
-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.json_extractor import JsonExtractorNode
-from lmnr.cli.parser.nodes.llm import LLMNode
-from lmnr.cli.parser.nodes.output import OutputNode
-from lmnr.cli.parser.nodes.router import Route, RouterNode
-from lmnr.cli.parser.nodes.semantic_search import (
-    Dataset,
-    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,
-    JsonExtractorNode,
-]
-
-
-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"]),
-        )
-    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,
-            structured_output_enabled=node_dict.get("structuredOutputEnabled", False),
-            structured_output_max_retries=node_dict.get(
-                "structuredOutputMaxRetries", 0
-            ),
-            structured_output_schema=node_dict.get("structuredOutputSchema", None),
-            structured_output_schema_target=node_dict.get(
-                "structuredOutputSchemaTarget", None
-            ),
-        )
-    elif node_dict["type"] == "Router":
-        return RouterNode(
-            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"],
-            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()
-            },
-            code=node_dict["code"],
-            fn_name=node_dict["fnName"],
-        )
-    elif node_dict["type"] == "JsonExtractor":
-        return JsonExtractorNode(
-            id=uuid.UUID(node_dict["id"]),
-            name=node_dict["name"],
-            inputs=[Handle.from_dict(handle) for handle in node_dict["inputs"]],
-            outputs=[Handle.from_dict(handle) for handle in node_dict["outputs"]],
-            inputs_mappings={
-                uuid.UUID(k): uuid.UUID(v)
-                for k, v in node_dict["inputsMappings"].items()
-            },
-            template=node_dict["template"],
-        )
-    else:
-        raise ValueError(f"Node type {node_dict['type']} not supported")

lmnr/cli/parser/parser.py

@@ -1,62 +0,0 @@
-from lmnr.cli.parser.utils import replace_spaces_with_underscores
-from .nodes.types import node_from_dict
-
-
-def runnable_graph_to_template_vars(graph: dict) -> dict:
-    """
-    Convert a runnable graph to template vars to be rendered in a cookiecutter context.
-    """
-    node_id_to_node_name = {}
-    output_handle_id_to_node_name: dict[str, str] = {}
-    for node in graph["nodes"].values():
-        # override node names in the graph itself to be safe
-        node["name"] = replace_spaces_with_underscores(node["name"])
-
-        node_id_to_node_name[node["id"]] = node["name"]
-        for handle in node["outputs"]:
-            output_handle_id_to_node_name[handle["id"]] = node["name"]
-
-    tasks = []
-    for node_obj in graph["nodes"].values():
-        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,
-                "function_name": f"run_{node.name}",
-                "node_type": node_type,
-                "handles_mapping": handles_mapping,
-                # since we map from to to from, all 'to's won't repeat
-                "input_handle_names": [
-                    handle_name for (handle_name, _) in handles_mapping
-                ],
-                "handle_args": ", ".join(
-                    [f"{handle_name}: NodeInput" for handle_name in unique_handles]
-                ),
-                "prev": [],
-                "next": [],
-                "config": node.config(),
-            }
-        )
-
-    for to, from_ in graph["pred"].items():
-        # TODO: Make "tasks" a hashmap from node id (as str!) to task
-        to_task = [task for task in tasks if task["name"] == node_id_to_node_name[to]][
-            0
-        ]
-        from_tasks = []
-        for f in from_:
-            from_tasks.append(
-                [task for task in tasks if task["name"] == node_id_to_node_name[f]][0]
-            )
-
-        for from_task in from_tasks:
-            to_task["prev"].append(from_task["name"])
-            from_task["next"].append(node_id_to_node_name[to])
-
-    # Return as a hashmap due to cookiecutter limitations, investigate later.
-    return {task["name"]: task for task in tasks}

lmnr/cli/parser/utils.py

@@ -1,49 +0,0 @@
-# Convert a list of handles to a map of input handle names
-# to their respective values
-import uuid
-from .nodes import Handle
-
-
-def map_handles(
-    inputs: list[Handle],
-    inputs_mappings: dict[uuid.UUID, uuid.UUID],
-    output_handle_id_to_node_name: dict[str, str],
-) -> list[tuple[str, str]]:
-    mapping = []
-
-    for to, from_ in inputs_mappings.items():
-        for input in inputs:
-            if input.id == to:
-                mapping.append((input.name, from_))
-                break
-        else:
-            raise ValueError(f"Input handle {to} not found in inputs")
-
-    return [
-        (input_name, output_handle_id_to_node_name[str(output_id)])
-        for input_name, output_id in mapping
-    ]
-
-
-def replace_spaces_with_underscores(s: str):
-    spaces = [
-        "\u0020",
-        "\u00A0",
-        "\u1680",
-        "\u2000",
-        "\u2001",
-        "\u2002",
-        "\u2003",
-        "\u2004",
-        "\u2005",
-        "\u2006",
-        "\u2007",
-        "\u2008",
-        "\u2009",
-        "\u200A",
-        "\u200B",
-        "\u202F",
-        "\u205F",
-        "\u3000",
-    ]
-    return s.translate({ord(space): "_" for space in spaces})

lmnr/cli/zip.py

@@ -1,16 +0,0 @@
-import os
-from pathlib import Path
-import zipfile
-
-
-def zip_directory(directory_path: Path, zip_file_path: Path):
-    with zipfile.ZipFile(zip_file_path, "w", zipfile.ZIP_DEFLATED) as zipf:
-        for root, _, files in os.walk(directory_path):
-            for file in files:
-                # Don't include the zip file itself, otherwise goes to infinite loop
-                if file == zip_file_path.name:
-                    continue
-
-                file_path = os.path.join(root, file)
-                arcname = os.path.relpath(file_path, directory_path)
-                zipf.write(file_path, arcname)

lmnr/sdk/endpoint.py

@@ -1,186 +0,0 @@
-import json
-from pydantic.alias_generators import to_snake
-import pydantic
-import requests
-from lmnr.types import (
-    EndpointRunError, EndpointRunResponse, NodeInput, EndpointRunRequest,
-    ToolCallError, ToolCallRequest, ToolCallResponse, SDKError
-)
-from typing import Callable, Optional
-from websockets.sync.client import connect
-
-class Laminar:
-    project_api_key: Optional[str] = None
-    def __init__(self, project_api_key: str):
-        """Initialize the Laminar object with your project API key
-
-        Args:
-            project_api_key (str):
-                Project api key. Generate or view your keys
-                in the project settings in the Laminar dashboard.
-        """        
-        self.project_api_key = project_api_key
-        self.url = 'https://api.lmnr.ai/v2/endpoint/run'
-        self.ws_url = 'wss://api.lmnr.ai/v2/endpoint/ws'
-    
-    def run (
-        self,
-        endpoint: str,
-        inputs: dict[str, NodeInput],
-        env: dict[str, str] = {},
-        metadata: dict[str, str] = {},
-        tools: list[Callable[..., NodeInput]] = [],
-    ) -> EndpointRunResponse:
-        """Runs the endpoint with the given inputs
-
-        Args:
-            endpoint (str): name of the Laminar endpoint
-            inputs (dict[str, NodeInput]):
-                inputs to the endpoint's target pipeline.
-                Keys in the dictionary must match input node names
-            env (dict[str, str], optional):
-                Environment variables for the pipeline execution.
-                Defaults to {}.
-            metadata (dict[str, str], optional):
-                any custom metadata to be stored
-                with execution trace. Defaults to {}.
-            tools (list[Callable[..., NodeInput]], optional):
-                List of callable functions the execution can call as tools.
-                If specified and non-empty, a bidirectional communication
-                with Laminar API through websocket will be established.
-                Defaults to [].
-
-        Returns:
-            EndpointRunResponse: response object containing the outputs
-        
-        Raises:
-            ValueError: if project API key is not set
-            EndpointRunError: if the endpoint run fails
-            SDKError: if an error occurs on client side during the execution
-        """        
-        if self.project_api_key is None:
-            raise ValueError(
-                'Please initialize the Laminar object with' 
-                ' your project API key'
-            )
-        if tools:
-            return self._run_websocket(endpoint, inputs, env, metadata, tools)
-        return self._run(endpoint, inputs, env, metadata)
-    
-    def _run(
-        self,
-        endpoint: str,
-        inputs: dict[str, NodeInput],
-        env: dict[str, str] = {},
-        metadata: dict[str, str] = {}
-    ) -> EndpointRunResponse:
-        try:
-            request = EndpointRunRequest(
-                inputs = inputs,
-                endpoint = endpoint,
-                env = env,
-                metadata = metadata
-            )
-        except Exception as e:
-            raise ValueError(f'Invalid request: {e}')
-        response = requests.post(
-            self.url, 
-            json=json.loads(request.model_dump_json()),
-            headers={'Authorization': f'Bearer {self.project_api_key}'}
-        )
-        if response.status_code != 200:
-            raise EndpointRunError(response)
-        try:
-            resp_json = response.json()
-            keys = list(resp_json.keys())
-            for key in keys:
-                value = resp_json[key]
-                del resp_json[key]
-                resp_json[to_snake(key)] = value
-            return EndpointRunResponse(**resp_json)
-        except:
-            raise EndpointRunError(response)
-
-    def _run_websocket(
-        self,
-        endpoint: str,
-        inputs: dict[str, NodeInput],
-        env: dict[str, str] = {},
-        metadata: dict[str, str] = {},
-        tools: list[Callable[..., NodeInput]] = [],
-    ) -> EndpointRunResponse:
-        try:
-            request = EndpointRunRequest(
-                inputs = inputs,
-                endpoint = endpoint,
-                env = env,
-                metadata = metadata
-            )
-        except Exception as e:
-            raise ValueError(f'Invalid request: {e}')
-
-        with connect(
-            self.ws_url,
-            additional_headers={
-                'Authorization': f'Bearer {self.project_api_key}'
-            }
-        ) as websocket:
-            websocket.send(request.model_dump_json())
-            req_id = None
-
-            while True:
-                message = websocket.recv()
-                try:
-                    tool_call = ToolCallRequest.model_validate_json(message)
-                    req_id = tool_call.req_id
-                    matching_tools = [
-                        tool for tool in tools
-                        if tool.__name__ == tool_call.toolCall.function.name
-                    ]
-                    if not matching_tools:
-                        raise SDKError(
-                            f'Tool {tool_call.toolCall.function.name} not found.'
-                            ' Registered tools: '
-                            f'{", ".join([tool.__name__ for tool in tools])}'
-                        )
-                    tool = matching_tools[0]
-                        # default the arguments to an empty dictionary
-                    if tool.__name__ == tool_call.toolCall.function.name:
-                        arguments = {}
-                        try:
-                            arguments = json.loads(tool_call.toolCall.function.arguments)
-                        except:
-                            pass
-                        try:
-                            response = tool(**arguments)
-                        except Exception as e:
-                            error_message = 'Error occurred while running tool' +\
-                             f'{tool.__name__}: {e}'
-                            e = ToolCallError(error=error_message, reqId=req_id)
-                            websocket.send(e.model_dump_json())
-                        formatted_response = None
-                        try:
-                            formatted_response = ToolCallResponse(
-                                reqId=tool_call.reqId,
-                                response=response
-                            )
-                        except pydantic.ValidationError as e:
-                            formatted_response = ToolCallResponse(
-                                reqId=tool_call.reqId,
-                                response=str(response)
-                            )
-                        websocket.send(
-                            formatted_response.model_dump_json()
-                        )
-                except pydantic.ValidationError as e:
-                    message_json = json.loads(message)
-                    keys = list(message_json.keys())
-                    for key in keys:
-                        value = message_json[key]
-                        del message_json[key]
-                        message_json[to_snake(key)] = value
-                    result = EndpointRunResponse.model_validate(message_json)
-                    websocket.close()
-                    return result
-                except Exception as e:
-                    raise SDKError(f'Error communicating to backend through websocket {e}')

lmnr/sdk/registry.py

@@ -1,29 +0,0 @@
-from typing import Callable
-
-from lmnr.types import NodeFunction, NodeInput
-
-
-class Registry:
-    """
-    Class to register and resolve node functions based on their node names.
-
-    Node names cannot have space in their name.
-    """
-
-    functions: dict[str, NodeFunction]
-
-    def __init__(self):
-        self.functions = {}
-
-    def add(self, node_name: str, function: Callable[..., NodeInput]):
-        self.functions[node_name] = NodeFunction(node_name, function)
-
-    def func(self, node_name: str):
-        def decorator(f: Callable[..., NodeInput]):
-            self.add(node_name, f)
-            return f
-
-        return decorator
-
-    def get(self, node_name: str) -> Callable[..., NodeInput]:
-        return self.functions[node_name].function