lmnr 0.2.9__tar.gz → 0.2.10__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lmnr
-Version: 0.2.9
+Version: 0.2.10
 Summary: Python SDK for Laminar AI
 License: Apache-2.0
 Author: lmnr.ai

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

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

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.9 → 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.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.9 → 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.9/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.9/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}
-
-========================================
-"""
-
-