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

lmnr/__init__.py

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

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

@@ -12,6 +12,8 @@ class CodeNode(NodeFunctions):
     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]
@@ -24,4 +26,11 @@ class CodeNode(NodeFunctions):
         return "Code"
 
     def config(self) -> dict:
-        return {}
+        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/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/cli/parser/nodes/json_extractor.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, NodeFunctions
+from lmnr.cli.parser.utils import map_handles
+
+
+@dataclass
+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]
+    ) -> list[tuple[str, str]]:
+        return map_handles(
+            self.inputs, self.inputs_mappings, output_handle_id_to_node_name
+        )
+
+    def node_type(self) -> str:
+        return "JsonExtractor"
+
+    def config(self) -> dict:
+        return {"template": self.template}

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/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/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/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/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/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/sdk/remote_debugger.py

@@ -1,34 +1,45 @@
-from typing import Callable, Optional
+from typing import Callable, Optional, Union
 from websockets.sync.client import connect
 import pydantic
 import websockets
 from lmnr.types import (
-    DeregisterDebuggerRequest, NodeInput, RegisterDebuggerRequest,
-    SDKError, ToolCallError, ToolCallRequest, ToolCallResponse
+    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: list[Callable[..., NodeInput]] = []
+        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.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()
@@ -37,17 +48,13 @@ class RemoteDebugger:
         # 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):
+        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}'
-            }
+            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())
@@ -55,7 +62,7 @@ class RemoteDebugger:
 
             while not self.stop_flag:
                 try:
-                    # blocks the thread until a message 
+                    # blocks the thread until a message
                     # is received or a timeout (3 seconds) occurs
                     message = websocket.recv(3)
                 except TimeoutError:
@@ -66,55 +73,48 @@ class RemoteDebugger:
                 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])}
+                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_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()
+                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
+                    debuggerSessionId=self.session, deregister=True
                 ).model_dump_json()
             )
 
@@ -122,10 +122,8 @@ class RemoteDebugger:
         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"""
+        registered_functions = ",\n".join(["- " + k for k in self.tools.keys()])
+        return f"""
 ========================================
 Debugger Session ID:
 {self.session}
@@ -136,5 +134,3 @@ Registered functions:
 
 ========================================
 """
-
-    

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.dist-info → lmnr-0.2.10.dist-info}/METADATA

@@ -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.10.dist-info/RECORD

@@ -0,0 +1,28 @@
+lmnr/__init__.py,sha256=BBJ87AiHC_OpaYOCzF8QSsf7eO3LlJPOCBXHNKurbE4,235
+lmnr/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lmnr/cli/__main__.py,sha256=8hDtWlaFZK24KhfNq_ZKgtXqYHsDQDetukOCMlsbW0Q,59
+lmnr/cli/cli.py,sha256=qG3-aY2EJIW3BSD-_s1vUsxHcxC9kiuIeAO8aVUq3ik,4103
+lmnr/cli/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lmnr/cli/parser/nodes/__init__.py,sha256=2MkPdKulb1kuNe6aT71CaqBA8iBrXyb5pq5bu_EvCb8,1052
+lmnr/cli/parser/nodes/code.py,sha256=8lTPBibUzaw_t-9QoPljhxH3KA4CLn9DJjA-iWpprOA,933
+lmnr/cli/parser/nodes/condition.py,sha256=AJny0ILXbSy1hTwsRvZvDUqts9INNx63yQSkD7Dp7KU,740
+lmnr/cli/parser/nodes/input.py,sha256=o8EfCmBbNyQL8FzmAtgnNDFlWqZmRAgkbw4HzKXZepU,539
+lmnr/cli/parser/nodes/json_extractor.py,sha256=CnVwZ-wU_Ro4WkJLw9Uk_SS3yvZ66UPa5mK4JdkM8w4,723
+lmnr/cli/parser/nodes/llm.py,sha256=Wpmo9cfNiYN9DRbj7oBS6RYcKXLwlGtF6RdF4jFQm5I,1866
+lmnr/cli/parser/nodes/output.py,sha256=1XBppSscxM01kfZhE9oOh2GgdCVzyPVe2RAxLI5HmUc,665
+lmnr/cli/parser/nodes/router.py,sha256=dmCx4ho8_GdFJXQa8UevMf_uEP7AKBv_MJ2zpLC6Vck,894
+lmnr/cli/parser/nodes/semantic_search.py,sha256=DWDPpV78XZ7vPIaPd86FbeDFAnKah4e61M1TOzwnt84,1352
+lmnr/cli/parser/nodes/types.py,sha256=OVXj-iMEDY9nPKCX1-zddtoszZcUL3CXYYryI7O3et0,6094
+lmnr/cli/parser/parser.py,sha256=yDa-ysAkh6si_hHU8Gw8EdtNWc4pFc5RbvgWEXGEPys,2370
+lmnr/cli/parser/utils.py,sha256=1oy6BApHXOF7BTXbP8v3Oi9bwOdWZjoxDlRIOfXVxro,1169
+lmnr/cli/zip.py,sha256=DpAfSVg6k0Ly55SY7rsIZkX0XG6U6IPD-HzsNi5Cf-U,445
+lmnr/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lmnr/sdk/endpoint.py,sha256=0HjcxMUcJz-klFZO2f5xtTaoLjcaEb8vrJ_YldTWUc8,7467
+lmnr/sdk/registry.py,sha256=sEYQFOjO72YvgBSEkBrvoewFExoyBzx6nELgBarvD6Y,755
+lmnr/sdk/remote_debugger.py,sha256=BYAN13KUDxH412qD3HXdDH0RfokrePquDt35fzB7GUg,5010
+lmnr/types.py,sha256=3HpLBQZr6F5YMISHYLnzzyrTwUttNqJxpyobw31YYJQ,2347
+lmnr-0.2.10.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
+lmnr-0.2.10.dist-info/METADATA,sha256=STv0WzrtahyFBUaq_uLDuPVts5pd3dLgCfjdeQJ0Oyk,5565
+lmnr-0.2.10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+lmnr-0.2.10.dist-info/entry_points.txt,sha256=Qg7ZRax4k-rcQsZ26XRYQ8YFSBiyY2PNxYfq4a6PYXI,41
+lmnr-0.2.10.dist-info/RECORD,,

lmnr-0.2.8.dist-info/RECORD

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