lmnr 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

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/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/semantic_search.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from datetime import datetime
 
 import uuid
 
@@ -7,44 +6,19 @@ 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]
+    # created_at: datetime
+    # project_id: uuid.UUID
+    # name: str
+    # indexed_on: Optional[str]
 
     @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']}"
-            )
+    def from_dict(cls, dataset_dict: dict) -> "Dataset":
+        return cls(
+            id=uuid.UUID(dataset_dict["id"]),
+        )
 
 
 @dataclass
@@ -57,7 +31,7 @@ class SemanticSearchNode(NodeFunctions):
     limit: int
     threshold: float
     template: str
-    datasources: list[SemanticSearchDatasource]
+    datasets: list[Dataset]
 
     def handles_mapping(
         self, output_handle_id_to_node_name: dict[str, str]
@@ -74,8 +48,6 @@ class SemanticSearchNode(NodeFunctions):
             "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]
-            ),
+            "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

@@ -5,11 +5,12 @@ 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 (
-    SemanticSearchDatasource,
+    Dataset,
     SemanticSearchNode,
 )
 from lmnr.types import NodeInput, ChatMessage
@@ -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(
@@ -118,10 +122,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(
@@ -133,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/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.dist-info → lmnr-0.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lmnr
-Version: 0.2.7
+Version: 0.2.9
 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)
@@ -166,12 +168,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.9.dist-info/RECORD

@@ -0,0 +1,25 @@
+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=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/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.9.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
+lmnr-0.2.9.dist-info/METADATA,sha256=80S5dQujRPHbBr-zlV4W1GouTyFybBR7z2JanLJSuo4,5564
+lmnr-0.2.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+lmnr-0.2.9.dist-info/entry_points.txt,sha256=Qg7ZRax4k-rcQsZ26XRYQ8YFSBiyY2PNxYfq4a6PYXI,41
+lmnr-0.2.9.dist-info/RECORD,,

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

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

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/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/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/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/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/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/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/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="",
-        )

lmnr-0.2.7.dist-info/RECORD

@@ -1,35 +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=pzr5LUILi7TcaJIkC-CzmT7RG7-HWApQmUpgK9bc7mI,2847
-lmnr/cli/cookiecutter.json,sha256=PeiMMzCPzDhsapqYoAceYGPI5lOUNimvFzh5KeQv5QE,359
-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=o_XCR7BShAq8VGeKjPTwL6MxLdB07XHSd5CE71sFFiY,2105
-lmnr/cli/parser/nodes/types.py,sha256=NRhlgI3WGd86AToo-tU974DEZzbLaH4iDdP-hEEQiIo,5343
-lmnr/cli/parser/parser.py,sha256=kAZEeg358lyj_Q1IIhQB_bA7LW3Aw6RduShIfUSmLqQ,2173
-lmnr/cli/parser/utils.py,sha256=wVaqHVOR9VXl8Og9nkVyCVgHIcgbtYGkDOEGPtmjZ8g,715
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/__init__.py,sha256=pLVZqvDnNf9foGR-HXnX2F7WC2TWmyCTNcUctG8SXAI,27
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/action.py,sha256=mZMQwwPV5LtSfwdwQ7HefI3ttvwuokp4mhVI_Xn1Zck,274
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/engine.py,sha256=kCY6J7oQpm3f9YCYY2ZBzM_9bUv_XYTCRD_uFa6PLWQ,9640
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/state.py,sha256=wTx7jAv7b63-8k34cYfQp_DJxhCCOYT_qRHkmnZfnc0,1686
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/task.py,sha256=ware5VIrZvluHH3mpH6h7G0YDk5L0buSQ7s09za4Fro,1200
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/pipelines/{{cookiecutter.pipeline_dir_name}}/__init__.py,sha256=bsfbNUBYtKv37qzc_GLhSAzBam2lnowP_dlr8pubhcg,80
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/pipelines/{{cookiecutter.pipeline_dir_name}}/nodes/functions.py,sha256=Bwu8p7m16NAyt9wC0DTQL0MrHbM44WylLs5wTLwSxBM,7845
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/pipelines/{{cookiecutter.pipeline_dir_name}}/{{cookiecutter.pipeline_dir_name}}.py,sha256=WG-ZMofPpGXCx5jdWVry3_XBzcKjqn8ZycFSiWEOBPg,2858
-lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/types.py,sha256=iWuflMV7TiaBPs6-B-BlrovvWpZgHGGHK0v8rSqER7A,997
-lmnr/sdk/endpoint.py,sha256=0HjcxMUcJz-klFZO2f5xtTaoLjcaEb8vrJ_YldTWUc8,7467
-lmnr/sdk/remote_debugger.py,sha256=vCpMz7y3uboOi81qEwr8z3fhQ2H1y2YtJAxXVtb6uCA,5141
-lmnr/types.py,sha256=OR9xRAQ5uTTwpJTDL_e3jZqxYJWvyX96CCoxr3oo94g,2112
-lmnr-0.2.7.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
-lmnr-0.2.7.dist-info/METADATA,sha256=Ya1KVPAiyGxAZybuXSum8wmy4l-SnyYvaTTrvQ7uZRU,5427
-lmnr-0.2.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-lmnr-0.2.7.dist-info/entry_points.txt,sha256=Qg7ZRax4k-rcQsZ26XRYQ8YFSBiyY2PNxYfq4a6PYXI,41
-lmnr-0.2.7.dist-info/RECORD,,