lmnr 0.2.8__tar.gz → 0.2.10__tar.gz

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

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

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

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

lmnr-0.2.10/src/lmnr/__init__.py

@@ -0,0 +1,4 @@
+from .sdk.endpoint import Laminar
+from .types import ChatMessage, EndpointRunError, EndpointRunResponse, NodeInput
+from .sdk.remote_debugger import RemoteDebugger as LaminarRemoteDebugger
+from .sdk.registry import Registry as Pipeline

{lmnr-0.2.8 → lmnr-0.2.10}/src/lmnr/cli/cli.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 import requests
 from dotenv import load_dotenv
 import os
@@ -6,6 +7,8 @@ import logging
 from cookiecutter.main import cookiecutter
 from pydantic.alias_generators import to_pascal
 
+from lmnr.cli.zip import zip_directory
+
 from .parser.parser import runnable_graph_to_template_vars
 
 logger = logging.getLogger(__name__)
@@ -92,3 +95,42 @@ def pull(pipeline_name, pipeline_version_name, project_api_key, loglevel):
         no_input=True,
         overwrite_if_exists=True,
     )
+
+
+@cli.command(name="deploy")
+@click.argument("endpoint_id")
+@click.option(
+    "-p",
+    "--project-api-key",
+    help="Project API key",
+)
+def deploy(endpoint_id, project_api_key):
+    project_api_key = project_api_key or os.environ.get("LMNR_PROJECT_API_KEY")
+    if not project_api_key:
+        load_dotenv()
+        project_api_key = os.environ.get("LMNR_PROJECT_API_KEY")
+    if not project_api_key:
+        raise ValueError("LMNR_PROJECT_API_KEY is not set")
+
+    current_directory = Path.cwd()
+    zip_file_path = current_directory / "archive.zip"
+
+    zip_directory(current_directory, zip_file_path)
+
+    try:
+        url = f"https://api.lmnr.ai/v2/endpoints/{endpoint_id}/deploy-code"
+        with open(zip_file_path, "rb") as f:
+            headers = {
+                "Authorization": f"Bearer {project_api_key}",
+            }
+            files = {"file": f}
+            response = requests.post(url, headers=headers, files=files)
+
+            if response.status_code != 200:
+                raise ValueError(
+                    f"Error in deploying code: {response.status_code}\n{response.text}"
+                )
+    except Exception:
+        logging.exception("Error in deploying code")
+    finally:
+        Path.unlink(zip_file_path, missing_ok=True)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

lmnr-0.2.10/src/lmnr/cli/zip.py

@@ -0,0 +1,12 @@
+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:
+                file_path = os.path.join(root, file)
+                arcname = os.path.relpath(file_path, directory_path)
+                zipf.write(file_path, arcname)

lmnr-0.2.10/src/lmnr/sdk/registry.py

@@ -0,0 +1,29 @@
+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

lmnr-0.2.10/src/lmnr/sdk/remote_debugger.py

@@ -0,0 +1,136 @@
+from typing import Callable, Optional, Union
+from websockets.sync.client import connect
+import pydantic
+import websockets
+from lmnr.types import (
+    DeregisterDebuggerRequest,
+    NodeFunction,
+    NodeInput,
+    RegisterDebuggerRequest,
+    SDKError,
+    ToolCallError,
+    ToolCallRequest,
+    ToolCallResponse,
+)
+import uuid
+import json
+from threading import Thread
+
+
+class RemoteDebugger:
+    def __init__(
+        self,
+        project_api_key: str,
+        tools: Union[dict[str, NodeFunction], list[Callable[..., NodeInput]]] = [],
+    ):
+        # for simplicity and backwards compatibility, we allow the user to pass a list
+        if isinstance(tools, list):
+            tools = {f.__name__: NodeFunction(f.__name__, f) for f in tools}
+
+        self.project_api_key = project_api_key
+        self.url = "wss://api.lmnr.ai/v2/endpoint/ws"
+        self.tools = tools
+        self.thread = Thread(target=self._run)
+        self.stop_flag = False
+        self.session = None
+
+    def start(self) -> Optional[str]:
+        self.stop_flag = False
+        self.session = self._generate_session_id()
+        self.thread.start()
+        return self.session
+
+    def stop(self):
+        self.stop_flag = True
+        self.thread.join()
+        self.session = None
+        # python allows running threads only once, so we need to create
+        # a new thread
+        # in case the user wants to start the debugger again
+        self.thread = Thread(target=self._run)
+
+    def _run(self):
+        assert self.session is not None, "Session ID not set"
+        request = RegisterDebuggerRequest(debuggerSessionId=self.session)
+        with connect(
+            self.url,
+            additional_headers={"Authorization": f"Bearer {self.project_api_key}"},
+        ) as websocket:
+            websocket.send(request.model_dump_json())
+            print(self._format_session_id_and_registerd_functions())
+            req_id = None
+
+            while not self.stop_flag:
+                try:
+                    # blocks the thread until a message
+                    # is received or a timeout (3 seconds) occurs
+                    message = websocket.recv(3)
+                except TimeoutError:
+                    continue
+                except websockets.exceptions.ConnectionClosedError:
+                    print("Connection closed. Please restart the debugger.")
+                    return
+                try:
+                    tool_call = ToolCallRequest.model_validate_json(message)
+                    req_id = tool_call.reqId
+                except Exception:
+                    raise SDKError(f"Invalid message received:\n{message}")
+                matching_tool = self.tools.get(tool_call.toolCall.function.name)
+                if matching_tool is None:
+                    error_message = (
+                        f"Tool {tool_call.toolCall.function.name} not found"
+                        + ". Registered tools: "
+                        + ", ".join(self.tools.keys())
+                    )
+                    e = ToolCallError(error=error_message, reqId=req_id)
+                    websocket.send(e.model_dump_json())
+                    continue
+                tool = matching_tool.function
+
+                # default the arguments to an empty dictionary
+                arguments = {}
+                try:
+                    arguments = json.loads(tool_call.toolCall.function.arguments)
+                except Exception:
+                    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())
+                    continue
+                formatted_response = None
+                try:
+                    formatted_response = ToolCallResponse(
+                        reqId=tool_call.reqId, response=response
+                    )
+                except pydantic.ValidationError:
+                    formatted_response = ToolCallResponse(
+                        reqId=tool_call.reqId, response=str(response)
+                    )
+                websocket.send(formatted_response.model_dump_json())
+            websocket.send(
+                DeregisterDebuggerRequest(
+                    debuggerSessionId=self.session, deregister=True
+                ).model_dump_json()
+            )
+
+    def _generate_session_id(self) -> str:
+        return uuid.uuid4().urn[9:]
+
+    def _format_session_id_and_registerd_functions(self) -> str:
+        registered_functions = ",\n".join(["- " + k for k in self.tools.keys()])
+        return f"""
+========================================
+Debugger Session ID:
+{self.session}
+========================================
+
+Registered functions:
+{registered_functions}
+
+========================================
+"""

{lmnr-0.2.8 → lmnr-0.2.10}/src/lmnr/types.py

@@ -1,7 +1,7 @@
 import requests
 import pydantic
 import uuid
-from typing import Union, Optional
+from typing import Callable, Union, Optional
 
 
 class ChatMessage(pydantic.BaseModel):
@@ -90,3 +90,12 @@ class RegisterDebuggerRequest(pydantic.BaseModel):
 class DeregisterDebuggerRequest(pydantic.BaseModel):
     debuggerSessionId: str
     deregister: bool
+
+
+class NodeFunction:
+    node_name: str
+    function: Callable[..., NodeInput]
+
+    def __init__(self, node_name: str, function: Callable[..., NodeInput]):
+        self.node_name = node_name
+        self.function = function

lmnr-0.2.8/src/lmnr/__init__.py

@@ -1,8 +0,0 @@
-from .sdk.endpoint import Laminar
-from .types import (
-    ChatMessage,
-    EndpointRunError,
-    EndpointRunResponse,
-    NodeInput
-)
-from .sdk.remote_debugger import RemoteDebugger as LaminarRemoteDebugger

lmnr-0.2.8/src/lmnr/sdk/remote_debugger.py

@@ -1,140 +0,0 @@
-from typing import Callable, Optional
-from websockets.sync.client import connect
-import pydantic
-import websockets
-from lmnr.types import (
-    DeregisterDebuggerRequest, NodeInput, RegisterDebuggerRequest,
-    SDKError, ToolCallError, ToolCallRequest, ToolCallResponse
-)
-import uuid
-import json
-from threading import Thread
-
-class RemoteDebugger:
-    def __init__(
-        self,
-        project_api_key: str,
-        tools: list[Callable[..., NodeInput]] = []
-    ):
-        self.project_api_key = project_api_key
-        self.url = 'wss://api.lmnr.ai/v2/endpoint/ws'
-        self.tools = tools
-        self.thread = Thread(target=self._run)
-        self.stop_flag = False
-        self.session = None
-    
-    def start(self) -> Optional[str]:
-        self.stop_flag = False
-        self.session = self._generate_session_id()
-        self.thread.start()
-        return self.session
-    
-    def stop(self):
-        self.stop_flag = True
-        self.thread.join()
-        self.session = None
-        # python allows running threads only once, so we need to create
-        # a new thread
-        # in case the user wants to start the debugger again
-        self.thread = Thread(target=self._run)
-    
-    def get_session_id(self) -> str:
-        return self.session
-    
-    def _run(self):
-        request = RegisterDebuggerRequest(debuggerSessionId=self.session)
-        with connect(
-            self.url,
-            additional_headers={
-                'Authorization': f'Bearer {self.project_api_key}'
-            }
-        ) as websocket:
-            websocket.send(request.model_dump_json())
-            print(self._format_session_id_and_registerd_functions())
-            req_id = None
-
-            while not self.stop_flag:
-                try:
-                    # blocks the thread until a message 
-                    # is received or a timeout (3 seconds) occurs
-                    message = websocket.recv(3)
-                except TimeoutError:
-                    continue
-                except websockets.exceptions.ConnectionClosedError:
-                    print("Connection closed. Please restart the debugger.")
-                    return
-                try:
-                    tool_call = ToolCallRequest.model_validate_json(message)
-                    req_id = tool_call.reqId
-                except:
-                    raise SDKError(f'Invalid message received:\n{message}')
-                matching_tools = [
-                    tool for tool in self.tools
-                    if tool.__name__ == tool_call.toolCall.function.name
-                ]
-                if not matching_tools:
-                    error_message = \
-                        f'Tool {tool_call.toolCall.function.name} not found' +\
-                        '. Registered tools: ' +\
-                        {", ".join([tool.__name__ for tool in self.tools])}
-                    e = ToolCallError(error=error_message, reqId=req_id)
-                    websocket.send(e.model_dump_json())
-                    continue
-                tool = matching_tools[0]
-                if tool.__name__ == tool_call.toolCall.function.name:
-                    # default the arguments to an empty dictionary
-                    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())
-                        continue
-                    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()
-                    )
-            websocket.send(
-                DeregisterDebuggerRequest(
-                    debuggerSessionId=self.session,
-                    deregister=True
-                ).model_dump_json()
-            )
-
-    def _generate_session_id(self) -> str:
-        return uuid.uuid4().urn[9:]
-
-    def _format_session_id_and_registerd_functions(self) -> str:
-        registered_functions = \
-            ',\n'.join(['- ' + tool.__name__ for tool in self.tools])
-        return \
-f"""
-========================================
-Debugger Session ID:
-{self.session}
-========================================
-
-Registered functions:
-{registered_functions}
-
-========================================
-"""
-
-