llmio 0.0.1__py3-none-any.whl

llmio/__init__.py

@@ -0,0 +1,6 @@
+from .assistant import Assistant
+
+
+__all__ = [
+    "Assistant",
+]

llmio/assistant.py

@@ -0,0 +1,262 @@
+from typing import Literal, Optional, Callable, Type, Any
+from dataclasses import dataclass
+import textwrap
+from datetime import datetime
+from inspect import isclass, signature
+
+import jinja2
+import pydantic
+import openai
+from polyfactory.factories.pydantic_factory import ModelFactory
+
+from llmio import model, prompts
+
+
+ENGINES = {
+    "gpt-3.5-turbo",
+    "gpt-4",
+}
+
+
+@dataclass
+class Command:
+    function: Callable
+
+    @property
+    def name(self):
+        return self.function.__name__
+
+    @property
+    def is_pydantic_input(self):
+        return bool(
+            len(self.input_annotations) == 1
+            and issubclass(list(self.input_annotations.values())[0], pydantic.BaseModel)
+        )
+
+    @property
+    def is_pydantic_output(self):
+        annotation = self.function.__annotations__["return"]
+        if isclass(annotation) and issubclass(annotation, pydantic.BaseModel):
+            return True
+        return False
+
+    @property
+    def input_annotations(self):
+        return {
+            name: annotation
+            for name, annotation in self.function.__annotations__.items()
+            if name not in {"return", "state"}
+        }
+
+    @property
+    def params(self) -> pydantic.BaseModel:
+        if self.is_pydantic_input:
+            return list(self.input_annotations.values())[0]
+
+        return model.model_from_function(self.function)
+
+    @property
+    def returns(self) -> Type[pydantic.BaseModel]:
+        annotation = self.function.__annotations__["return"]
+        if isclass(annotation) and issubclass(annotation, pydantic.BaseModel):
+            return annotation
+
+        return pydantic.create_model("Result", result=(annotation, ...))
+
+    @property
+    def description(self):
+        if self.function.__doc__ is None:
+            return ""
+        return textwrap.dedent(self.function.__doc__).strip()
+
+    def explain(self):
+        return jinja2.Template(
+            prompts.DEFAULT_COMMAND_PROMPT,
+            trim_blocks=True,
+            lstrip_blocks=True,
+        ).render(
+            name=self.name,
+            description=self.description,
+            params=[
+                (
+                    key,
+                    value["type"],
+                    value.get("description", "-"),
+                    key in self.params.schema()["required"],
+                )
+                for key, value in self.params.schema()["properties"].items()
+            ],
+            returns=[
+                (key, value["type"], value.get("description", "-"))
+                for key, value in self.returns.schema()["properties"].items()
+            ],
+            mock_data=self.mock_data().json(),
+        )
+
+    def command_model(self) -> Any:
+        return pydantic.create_model(
+            "Model", command=(Literal[self.name], ...), params=(self.params, ...)
+        )
+
+    def mock_data(self):
+        class Mocker(ModelFactory):
+            __model__ = self.command_model()
+
+        return Mocker.build()
+
+    def execute(self, params, state=None):
+        kwargs = {}
+        if "state" in signature(self.function).parameters:
+            kwargs["state"] = state
+
+        if self.is_pydantic_input:
+            result = self.function(params, **kwargs)
+        else:
+            result = self.function(**params.dict(), **kwargs)
+
+        if self.is_pydantic_output:
+            return result
+        return self.returns(result=result)
+
+
+class Assistant:
+    def __init__(
+        self,
+        key: str,
+        description: str,
+        engine: str = "gpt-4",
+        command_header: Optional[str] = None,
+    ):
+        openai.api_key = key
+
+        if engine not in ENGINES:
+            raise ValueError(f"Unknown engine {engine}")
+
+        self.engine = engine
+        self.description = description
+        self.commands: list[Command] = []
+
+        if command_header is None:
+            self.command_header = prompts.DEFAULT_COMMAND_HEADER
+        else:
+            self.command_header = command_header
+
+        self._prompt_inspectors: list[Callable] = []
+        self._output_inspectors: list[Callable] = []
+
+    def system_prompt(self) -> str:
+        return jinja2.Template(
+            prompts.DEFAULT_SYSTEM_PROMPT,
+            trim_blocks=True,
+            lstrip_blocks=True,
+        ).render(
+            description=self.description,
+            command_header=self.command_header,
+            commands=self.commands,
+            current_time=datetime.now().isoformat(),
+        )
+
+    def _get_system_prompt(self) -> dict[str, str]:
+        return {"role": "system", "content": self.system_prompt()}
+
+    def create_prompt(
+        self, message_history: list[dict[str, str]]
+    ) -> list[dict[str, str]]:
+        return [
+            self._get_system_prompt(),
+            *message_history,
+        ]
+
+    def command(self, function: Callable):
+        input_annotations = {
+            name: annotation
+            for name, annotation in function.__annotations__.items()
+            if name not in {"return", "state"}
+        }
+
+        assert (
+            len(input_annotations) == 1
+            and issubclass(list(input_annotations.values())[0], pydantic.BaseModel)
+        ) or (
+            not any(
+                issubclass(annotation, pydantic.BaseModel)
+                for annotation in input_annotations.values()
+            )
+        )
+
+        assert "return" in function.__annotations__
+
+        self.commands.append(
+            Command(function=function),
+        )
+        return function
+
+    def inspect_prompt(self, function: Callable):
+        self._prompt_inspectors.append(function)
+        return function
+
+    def inspect_output(self, function: Callable):
+        self._output_inspectors.append(function)
+        return function
+
+    def _run_prompt_inspectors(self, prompt: list[dict[str, str]], state) -> None:
+        for inspector in self._prompt_inspectors:
+            kwargs = {}
+            if "state" in signature(inspector).parameters:
+                kwargs["state"] = state
+            inspector(prompt, **kwargs)
+
+    def _run_content_inspectors(self, content: str, state) -> None:
+        for inspector in self._output_inspectors:
+            kwargs = {}
+            if "state" in signature(inspector).parameters:
+                kwargs["state"] = state
+            inspector(content, **kwargs)
+
+    def speak(
+        self,
+        message: str,
+        history: Optional[list[dict[str, str]]] = None,
+        state=None,
+        role="user",
+    ) -> tuple[str, list[dict[str, str]]]:
+        if history is None:
+            history = []
+        history = history[:]
+        history.append(
+            {
+                "role": role,
+                "content": message,
+            }
+        )
+
+        prompt = self.create_prompt(history)
+        self._run_prompt_inspectors(prompt, state)
+
+        result = openai.ChatCompletion.create(
+            model=self.engine,
+            messages=prompt,
+        )
+        content = result["choices"][0]["message"]["content"]
+        self._run_content_inspectors(content, state)
+
+        history.append(
+            {
+                "role": "assistant",
+                "content": content,
+            }
+        )
+        for command in self.commands:
+            cmd_model = command.command_model()
+            try:
+                inputs = cmd_model.parse_raw(content)
+            except pydantic.ValidationError:
+                continue
+            result = command.execute(inputs.params, state=state)
+            return self.speak(
+                result.json(),
+                history=history,
+                role="system",
+                state=state,
+            )
+        return content, history

llmio/model.py

@@ -0,0 +1,31 @@
+from typing import Any, Callable, Dict, Mapping, Tuple
+from inspect import Parameter, signature
+
+from pydantic import create_model
+from pydantic.typing import get_all_type_hints
+from pydantic.utils import to_camel
+
+
+def model_from_function(function: Callable):
+    parameters: Mapping[str, Parameter] = signature(function).parameters
+
+    type_hints = get_all_type_hints(function)
+    fields: Dict[str, Tuple[Any, Any]] = {}
+    for name, param in parameters.items():
+        if name == "state":
+            continue
+
+        if param.annotation is param.empty:
+            annotation = Any
+        else:
+            annotation = type_hints[name]
+
+        default = ... if param.default is param.empty else param.default
+        if param.kind == Parameter.POSITIONAL_OR_KEYWORD:
+            fields[name] = annotation, default
+        else:
+            raise ValueError(
+                "Unable to parse function signature. Only named arguments supported."
+            )
+
+    return create_model(to_camel(function.__name__), **fields)  # type: ignore

llmio/prompts/__init__.py

@@ -0,0 +1,82 @@
+import textwrap
+
+
+DEFAULT_COMMAND_HEADER = (
+    textwrap.dedent(
+        """
+    The following commands can be used.
+    If you intend to execute a command, only write a valid command and nothing else.
+    Do not try to both speak and execute a command at the same time,
+    as it will not be accepted as a command.
+    Also do not try to execute multiple commands at once.
+    You can chain commands, but if so, only execute one command at a time,
+    and then execute the next commands afterward.
+    Every time a command is executed, the results will be shown as a system message,
+    and you then get to either execute a new command or output a normal message
+    intended to the user.
+    Every time you return a normal text, this will stop the command iteration,
+    and the text will be shown to the user. Because of this, do not hint that
+    you will execute a command by saying something like "Ok, I will now do X".
+    Instead, first execute the command, and then write a normal message to the user.
+    Do not talk explicitly about the commands to the user,
+    these are hidden and only serve as your interface to the application backend.
+
+    Remember to always EITHER output a command (in json), or a normal message,
+    never both at the same time.
+"""
+    )
+    .strip()
+    .replace("\n", " ")
+)
+
+
+DEFAULT_COMMAND_PROMPT = textwrap.dedent(
+    """
+    Command: {{name}}
+    {% if description %}
+    Description:
+    {{description}}
+    {% endif %}
+    {% if params %}
+
+    Parameters:
+    | Name | Type | Description | Required |
+    | ---- | ---- | ----------- | -------- |
+    {% for param_name, param_type, param_desc, param_required in params %}
+    | {{param_name}} | {{param_type}} | {{param_desc}} | {{param_required}} |
+    {% endfor %}
+    {% endif %}
+
+    Returns:
+    | Name | Type | Description |
+    | ---- | ---- | ----------- |
+    {% for res_name, res_type, res_desc in returns %}
+    | {{res_name}} | {{res_type}} | {{res_desc}} |
+    {% endfor %}
+
+    Example usage:
+    {{mock_data}}
+
+    ---
+"""
+).strip()
+
+
+DEFAULT_SYSTEM_PROMPT = textwrap.dedent(
+    """
+    {{description}}
+
+    {{command_header}}
+
+    {% for command in commands %}
+    {{command.explain()}}
+    {% endfor %} \
+
+    System parameters:
+    The current time is {{current_time}}
+
+    You are limited to only answer question regarding the scope described above
+    and the available commands defined below.
+    For all other questions, politely decline to answer.
+"""
+).strip()

llmio-0.0.1.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: llmio
+Version: 0.0.1
+Summary: Easily connect large language models into your application
+Project-URL: Homepage, https://github.com/badgeir/llmio
+Project-URL: Bug Tracker, https://github.com/badgeir/llmio/issues
+Author-email: Peter Leupi <pleupi123@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: jinja2
+Requires-Dist: openai
+Requires-Dist: polyfactory
+Requires-Dist: pydantic
+Provides-Extra: examples
+Requires-Dist: bs4; extra == 'examples'
+Description-Content-Type: text/markdown
+
+# llmio
+## Easily connect large language models into your application.
+
+![pylint](https://github.com/badgeir/llmio/actions/workflows/pylint.yml/badge.svg)
+![mypy](https://github.com/badgeir/llmio/actions/workflows/mypy.yml/badge.svg)
+![ruff](https://github.com/badgeir/llmio/actions/workflows/ruff.yml/badge.svg)
+![tests](https://github.com/badgeir/llmio/actions/workflows/test.yml/badge.svg)
+
+# Setup
+
+```
+pip install llmio
+```
+
+# Example
+
+``` python
+import llmio
+
+
+assistant = llmio.Assistant(
+    description="""
+    You are a calculator.
+    Always use the provided commands to perform calculations,
+    never try to calculate on your own.
+    When being given a math problem, do not explain the steps,
+    only execute them necessary commands and then present the answer.
+    """,
+    key="<openai-key>",
+)
+
+
+@assistant.command
+def add(num1: float, num2: float) -> float:
+    """
+    Add two numbers
+    """
+    print(f"Adding {num1} + {num2}")
+    return num1 + num2
+
+
+@assistant.command
+def multiply(num1: float, num2: float) -> float:
+    """
+    Multiply two numbers
+    """
+    print(f"Multiplying {num1} * {num2}")
+    return num1 * num2
+
+
+reply, _ = assistant.speak("calculate the answer of (10 + 20) * 1337")
+print(reply)
+```

llmio-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+llmio/__init__.py,sha256=45J1oXd5fVw_C5UrQF_cCC5z3Gc_qWEwPYLBlz_DpTw,66
+llmio/assistant.py,sha256=f5G5Kk0MmG1uqNDMdCywoP3flefTtDolJL1t5ZgFwxA,7684
+llmio/model.py,sha256=tTaG3ZMH1ZoziXddM3RyyZ90lwCGJpLBKQW1V1wEJ3I,1050
+llmio/prompts/__init__.py,sha256=KdofnNu06VQojLzljyTjvm8qw3iQw-EHCDXmuTV83d4,2483
+llmio-0.0.1.dist-info/METADATA,sha256=jdIeSOfUlM0-Yi_qZFTHpnQvzMVr_11t3MihJ5WpLgU,1919
+llmio-0.0.1.dist-info/WHEEL,sha256=EI2JsGydwUL5GP9t6kzZv7G3HDPi7FuZDDf9In6amRM,87
+llmio-0.0.1.dist-info/licenses/LICENSE,sha256=QQpsve0-VHf467xw_343sMYyvurffTYPV7Mgh3Hmmoo,1064
+llmio-0.0.1.dist-info/RECORD,,

llmio-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.14.0
+Root-Is-Purelib: true
+Tag: py3-none-any

llmio-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 badgeir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.