lionagi 0.3.8__py3-none-any.whl → 0.5.0__py3-none-any.whl

lionagi/integrations/ollama_/api_endpoints/chat_completion/request_body.py

@@ -0,0 +1,46 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Literal
+
+from pydantic import Field
+
+from ..data_models import OllamaEndpointRequestBody
+from ..option_models import Option
+from .message_models import Message
+from .tool_models import Tool
+
+
+class OllamaChatCompletionRequestBody(OllamaEndpointRequestBody):
+    model: str = Field(description="The model name")
+
+    messages: list[Message] = Field(
+        description="The messages of the chat, this can be used to keep a chat memory"
+    )
+
+    tools: list[Tool] | None = Field(
+        None,
+        description="Tools for the model to use if supported. Requires 'stream' to be set to false",
+    )
+
+    format: Literal["json"] | None = Field(
+        None,
+        description="The format to return a response in. Currently the only accepted value is 'json'",
+    )
+
+    options: Option | None = Field(
+        None,
+        description="Additional model parameters listed in the documentation for the Modelfile",
+    )
+
+    stream: bool = Field(
+        True,
+        description="If false the response will be returned as a single response object, "
+        "rather than a stream of objects",
+    )
+
+    keep_alive: str | Literal[0] = Field(
+        "5m",
+        description="Controls how long the model will stay loaded into memory following the request.",
+    )

lionagi/integrations/ollama_/api_endpoints/chat_completion/response_body.py

@@ -0,0 +1,67 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+from pydantic import BaseModel, Field
+
+from ..data_models import OllamaEndpointResponseBody
+from .message_models import Message
+
+
+class Function(BaseModel):
+    name: str = Field(None, description="The name of the function to call.")
+    arguments: str = Field(
+        None, description="The arguments to pass to the function."
+    )
+
+
+class ToolCall(BaseModel):
+    function: Function = Field(None, description="The function call details.")
+
+
+class OllamaStreamChatCompletionResponseBody(OllamaEndpointResponseBody):
+    model: str = Field(None, description="The model name")
+
+    created_at: str = Field(
+        None, description="The timestamp when the response was created"
+    )
+
+    message: Message = Field(
+        None, description="he partial or full response generated by the model"
+    )
+
+    done: bool = Field(
+        None,
+        description="A flag indicating whether the response generation is complete",
+    )
+
+    done_reason: str = Field(
+        None, description="The response generation complete reason"
+    )
+
+
+class OllamaChatCompletionResponseBody(OllamaStreamChatCompletionResponseBody):
+    total_duration: int = Field(
+        None, description="Time spent generating the response"
+    )
+
+    load_duration: int = Field(
+        None, description="Time spent in nanoseconds loading the model"
+    )
+
+    prompt_eval_count: int = Field(
+        None, description="number of tokens in the prompt"
+    )
+
+    prompt_eval_duration: int = Field(
+        None, description="time spent in nanoseconds evaluating the prompt"
+    )
+
+    eval_count: int = Field(
+        None, description="number of tokens in the response"
+    )
+
+    eval_duration: int = Field(
+        None, description="time in nanoseconds spent generating the response"
+    )

lionagi/integrations/ollama_/api_endpoints/chat_completion/tool_models.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class FunctionParameters(BaseModel):
+    type: Literal["object"] = "object"
+    properties: dict[str, dict[str, Any]]
+    required: list[str] | None = None
+
+
+class Function(BaseModel):
+    description: str | None = Field(
+        None,
+        description=(
+            "A description of what the function does, used by the model to "
+            "choose when and how to call the function."
+        ),
+    )
+
+    name: str = Field(
+        max_length=64,
+        pattern="^[a-zA-Z0-9_-]+$",
+        description=(
+            "The name of the function to be called. Must be a-z, A-Z, 0-9, "
+            "or contain underscores and dashes, with a maximum length of 64."
+        ),
+    )
+
+    parameters: FunctionParameters | None = Field(
+        None,
+        description=(
+            "The parameters the functions accepts, described as a JSON Schema "
+            "object. See the guide for examples, and the JSON Schema "
+            "reference for documentation about the format."
+        ),
+    )
+
+
+class Tool(BaseModel):
+    type: Literal["function"] = Field(
+        description="The type of the tool. Currently, only function is supported."
+    )
+    function: Function = Field(description="The function definition.")

lionagi/integrations/ollama_/api_endpoints/completion/request_body.py

@@ -0,0 +1,72 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+from typing import List, Literal, Optional
+
+from pydantic import Field
+
+from ..data_models import OllamaEndpointRequestBody
+from ..option_models import Option
+
+
+class OllamaCompletionRequestBody(OllamaEndpointRequestBody):
+    model: str = Field(description="The model name")
+
+    prompt: str = Field(
+        None, description="The prompt to generate a response for"
+    )
+
+    suffix: str | None = Field(
+        None, description="The text after the model response"
+    )
+
+    images: list[str] | None = Field(
+        None,
+        description="A list of base64-encoded images (for multimodal models such as 'llava')",
+    )
+
+    format: Literal["json"] | None = Field(
+        None,
+        description="The format to return a response in. Currently the only accepted value is 'json'",
+    )
+
+    options: Option | dict | None = Field(
+        None,
+        description="Additional model parameters listed in the documentation for the 'Modelfile'",
+    )
+
+    system: str | None = Field(
+        None,
+        description="System message to (overrides what is defined in the 'Modelfile')",
+    )
+
+    template: str | None = Field(
+        None,
+        description="The prompt template to use (overrides what is defined in the 'Modelfile')",
+    )
+
+    context: list[int] | None = Field(
+        None,
+        description="The context parameter returned from a previous request to '/generate', "
+        "this can be used to keep a short conversational memory",
+    )
+
+    stream: bool = Field(
+        True,
+        description="If 'false' the response will be returned as a single response object, "
+        "rather than a stream of objects",
+    )
+
+    raw: bool = Field(
+        False,
+        description="if 'true' no formatting will be applied to the prompt. "
+        "You may choose to use the 'raw' parameter if you are specifying a full templated "
+        "prompt in your request to the API",
+    )
+
+    keep_alive: str | Literal[0] = Field(
+        "5m",
+        description="Controls how long the model will stay loaded into memory following the request.",
+    )

lionagi/integrations/ollama_/api_endpoints/completion/response_body.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+from typing import Optional
+
+from pydantic import Field
+
+from ..data_models import OllamaEndpointResponseBody
+
+
+class OllamaStreamCompletionResponseBody(OllamaEndpointResponseBody):
+    model: str = Field(None, description="The model name")
+
+    created_at: str = Field(
+        None, description="The timestamp when the response was created"
+    )
+
+    response: str = Field(
+        None, description="he partial or full response generated by the model"
+    )
+
+    done: bool = Field(
+        None,
+        description="A flag indicating whether the response generation is complete",
+    )
+
+
+class OllamaCompletionResponseBody(OllamaStreamCompletionResponseBody):
+    total_duration: int = Field(
+        None, description="Time spent generating the response"
+    )
+
+    load_duration: int = Field(
+        None, description="Time spent in nanoseconds loading the model"
+    )
+
+    prompt_eval_count: int = Field(
+        None, description="number of tokens in the prompt"
+    )
+
+    prompt_eval_duration: int = Field(
+        None, description="time spent in nanoseconds evaluating the prompt"
+    )
+
+    eval_count: int = Field(
+        None, description="number of tokens in the response"
+    )
+
+    eval_duration: int = Field(
+        None, description="time in nanoseconds spent generating the response"
+    )
+
+    context: list | None = Field(
+        None,
+        description="an encoding of the conversation used in this response, "
+        "this can be sent in the next request to keep a conversational memory",
+    )

lionagi/integrations/ollama_/api_endpoints/data_models.py

@@ -0,0 +1,15 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pydantic import BaseModel, ConfigDict
+
+
+class OllamaEndpointRequestBody(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid", use_enum_values=True, validate_assignment=True
+    )
+
+
+class OllamaEndpointResponseBody(BaseModel):
+    model_config = ConfigDict(use_enum_values=True, validate_assignment=True)

lionagi/integrations/ollama_/api_endpoints/embedding/request_body.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+from pydantic import Field
+
+from ..data_models import OllamaEndpointRequestBody
+from ..option_models import Option
+
+
+class OllamaEmbeddingRequestBody(OllamaEndpointRequestBody):
+    model: str = Field(description="Name of model to generate embeddings from")
+
+    input: str | list[str] = Field(
+        description="Text or list of text to generate embeddings for"
+    )
+
+    truncate: bool = Field(
+        True,
+        description="Truncates the end of each input to fit within context length. "
+        "Returns error if 'false' and context length is exceeded.",
+    )
+
+    options: Option | None = Field(
+        None,
+        description="Additional model parameters listed in the documentation for the Modelfile",
+    )
+
+    keep_alive: str = Field(
+        "5m",
+        description="Controls how long the model will stay loaded into memory following the request.",
+    )

lionagi/integrations/ollama_/api_endpoints/embedding/response_body.py

@@ -0,0 +1,29 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+from pydantic import Field
+
+from ..data_models import OllamaEndpointResponseBody
+
+
+class OllamaEmbeddingResponseBody(OllamaEndpointResponseBody):
+    model: str = Field(None, description="The model name")
+
+    embeddings: list = Field(
+        None,
+        description="The generated embeddings for the text or list of text",
+    )
+
+    total_duration: int = Field(
+        None, description="Time spent generating the response"
+    )
+
+    load_duration: int = Field(
+        None, description="Time spent in nanoseconds loading the model"
+    )
+
+    prompt_eval_count: int = Field(
+        None, description="Number of tokens in the prompt"
+    )

lionagi/integrations/ollama_/api_endpoints/match_data_model.py

@@ -0,0 +1,62 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+def match_data_model(task_name):
+    if task_name == "generate_completion":
+        from .completion.request_body import OllamaCompletionRequestBody
+
+        return {"request_body": OllamaCompletionRequestBody}
+
+    elif task_name == "generate_chat_completion":
+        from .chat_completion.request_body import (
+            OllamaChatCompletionRequestBody,
+        )
+
+        return {"request_body": OllamaChatCompletionRequestBody}
+
+    elif task_name == "generate_embeddings":
+        from .embedding.request_body import OllamaEmbeddingRequestBody
+
+        return {"request_body": OllamaEmbeddingRequestBody}
+
+    elif task_name == "create_model":
+        from .model.create_model import OllamaCreateModelRequestBody
+
+        return {"json_data": OllamaCreateModelRequestBody}
+
+    elif (
+        task_name == "list_local_models" or task_name == "list_running_models"
+    ):
+        return {}
+
+    elif task_name == "show_model_information":
+        from .model.show_model import OllamaShowModelRequestBody
+
+        return {"json_data": OllamaShowModelRequestBody}
+
+    elif task_name == "copy_model":
+        from .model.copy_model import OllamaCopyModelRequestBody
+
+        return {"json_data": OllamaCopyModelRequestBody}
+
+    elif task_name == "delete_model":
+        from .model.delete_model import OllamaDeleteModelRequestBody
+
+        return {"json_data": OllamaDeleteModelRequestBody}
+
+    elif task_name == "pull_model":
+        from .model.pull_model import OllamaPullModelRequestBody
+
+        return {"json_data": OllamaPullModelRequestBody}
+
+    elif task_name == "push_model":
+        from .model.push_model import OllamaPushModelRequestBody
+
+        return {"json_data": OllamaPushModelRequestBody}
+
+    else:
+        raise ValueError(
+            f"Invalid task: {task_name}. Not supported in the service."
+        )

lionagi/integrations/ollama_/api_endpoints/match_response.py

@@ -0,0 +1,190 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+imported_models = {}
+
+
+def match_response(request_model, response: dict | list):
+    global imported_models
+
+    endpoint = request_model.endpoint
+
+    if endpoint == "generate":
+        if isinstance(response, list):
+            if "OllamaStreamCompletionResponseBody" not in imported_models:
+                from .completion.response_body import (
+                    OllamaStreamCompletionResponseBody,
+                )
+
+                imported_models["OllamaStreamCompletionResponseBody"] = (
+                    OllamaStreamCompletionResponseBody
+                )
+            if "OllamaCompletionResponseBody" not in imported_models:
+                from .completion.response_body import (
+                    OllamaCompletionResponseBody,
+                )
+
+                imported_models["OllamaCompletionResponseBody"] = (
+                    OllamaCompletionResponseBody
+                )
+
+            result = []
+            for item in response[:-1]:
+                result.append(
+                    imported_models["OllamaStreamCompletionResponseBody"](
+                        **item
+                    )
+                )
+
+            result.append(
+                imported_models["OllamaCompletionResponseBody"](**response[-1])
+            )
+            return result
+        else:
+            if "OllamaCompletionResponseBody" not in imported_models:
+                from .completion.response_body import (
+                    OllamaCompletionResponseBody,
+                )
+
+                imported_models["OllamaCompletionResponseBody"] = (
+                    OllamaCompletionResponseBody
+                )
+            return imported_models["OllamaCompletionResponseBody"](**response)
+
+    elif endpoint == "chat":
+        if isinstance(response, list):
+            if "OllamaStreamChatCompletionResponseBody" not in imported_models:
+                from .chat_completion.response_body import (
+                    OllamaStreamChatCompletionResponseBody,
+                )
+
+                imported_models["OllamaStreamChatCompletionResponseBody"] = (
+                    OllamaStreamChatCompletionResponseBody
+                )
+            if "OllamaChatCompletionResponseBody" not in imported_models:
+                from .chat_completion.response_body import (
+                    OllamaChatCompletionResponseBody,
+                )
+
+                imported_models["OllamaChatCompletionResponseBody"] = (
+                    OllamaChatCompletionResponseBody
+                )
+
+            result = []
+            for item in response[:-1]:
+                result.append(
+                    imported_models["OllamaStreamChatCompletionResponseBody"](
+                        **item
+                    )
+                )
+
+            result.append(
+                imported_models["OllamaChatCompletionResponseBody"](
+                    **response[-1]
+                )
+            )
+            return result
+        else:
+            if "OllamaChatCompletionResponseBody" not in imported_models:
+                from .chat_completion.response_body import (
+                    OllamaChatCompletionResponseBody,
+                )
+
+                imported_models["OllamaChatCompletionResponseBody"] = (
+                    OllamaChatCompletionResponseBody
+                )
+            return imported_models["OllamaChatCompletionResponseBody"](
+                **response
+            )
+
+    elif endpoint == "embed":
+        if "OllamaEmbeddingResponseBody" not in imported_models:
+            from .embedding.response_body import OllamaEmbeddingResponseBody
+
+            imported_models["OllamaEmbeddingResponseBody"] = (
+                OllamaEmbeddingResponseBody
+            )
+        return imported_models["OllamaEmbeddingResponseBody"](**response)
+
+    elif endpoint == "create":
+        if "OllamaCreateModelResponseBody" not in imported_models:
+            from .model.create_model import OllamaCreateModelResponseBody
+
+            imported_models["OllamaCreateModelResponseBody"] = (
+                OllamaCreateModelResponseBody
+            )
+        if isinstance(response, list):
+            return [
+                imported_models["OllamaCreateModelResponseBody"](**res)
+                for res in response
+            ]
+        else:  # dict
+            return imported_models["OllamaCreateModelResponseBody"](**response)
+
+    elif endpoint == "tags":
+        if "OllamaListLocalModelsResponseBody" not in imported_models:
+            from .model.list_model import OllamaListLocalModelsResponseBody
+
+            imported_models["OllamaListLocalModelsResponseBody"] = (
+                OllamaListLocalModelsResponseBody
+            )
+        return imported_models["OllamaListLocalModelsResponseBody"](**response)
+
+    elif endpoint == "show":
+        if "OllamaShowModelResponseBody" not in imported_models:
+            from .model.show_model import OllamaShowModelResponseBody
+
+            imported_models["OllamaShowModelResponseBody"] = (
+                OllamaShowModelResponseBody
+            )
+        return imported_models["OllamaShowModelResponseBody"](**response)
+
+    elif endpoint == "pull":
+        if "OllamaPullModelResponseBody" not in imported_models:
+            from .model.pull_model import OllamaPullModelResponseBody
+
+            imported_models["OllamaPullModelResponseBody"] = (
+                OllamaPullModelResponseBody
+            )
+        if isinstance(response, list):
+            return [
+                imported_models["OllamaPullModelResponseBody"](**res)
+                for res in response
+            ]
+        else:  # dict
+            return imported_models["OllamaPullModelResponseBody"](**response)
+
+    elif endpoint == "push":
+        if "OllamaPushModelResponseBody" not in imported_models:
+            from .model.push_model import OllamaPushModelResponseBody
+
+            imported_models["OllamaPushModelResponseBody"] = (
+                OllamaPushModelResponseBody
+            )
+        if isinstance(response, list):
+            return [
+                imported_models["OllamaPushModelResponseBody"](**res)
+                for res in response
+            ]
+        else:  # dict
+            return imported_models["OllamaPushModelResponseBody"](**response)
+
+    elif endpoint == "ps":
+        if "OllamaListRunningModelsResponseBody" not in imported_models:
+            from .model.list_model import OllamaListRunningModelsResponseBody
+
+            imported_models["OllamaListRunningModelsResponseBody"] = (
+                OllamaListRunningModelsResponseBody
+            )
+        return imported_models["OllamaListRunningModelsResponseBody"](
+            **response
+        )
+
+    elif not response:
+        return
+
+    else:
+        raise ValueError(
+            "There is no standard response model for the provided request and response"
+        )

lionagi/integrations/ollama_/api_endpoints/model/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0

lionagi/integrations/ollama_/api_endpoints/model/copy_model.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pydantic import Field
+
+from ..data_models import OllamaEndpointRequestBody
+
+
+class OllamaCopyModelRequestBody(OllamaEndpointRequestBody):
+    source: str = Field(description="Name of the source existing model")
+
+    destination: str = Field(description="Name of the copy model")

lionagi/integrations/ollama_/api_endpoints/model/create_model.py

@@ -0,0 +1,28 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+from pydantic import Field
+
+from ..data_models import OllamaEndpointRequestBody, OllamaEndpointResponseBody
+
+
+class OllamaCreateModelRequestBody(OllamaEndpointRequestBody):
+    name: str = Field(description="name of the model to create")
+
+    modelfile: str | None = Field(
+        None, description="Contents of the Modelfile"
+    )
+
+    stream: bool | None = Field(
+        True,
+        description="if 'false' the response will be returned as a single response object, "
+        "rather than a stream of objects",
+    )
+
+    path: str | None = Field(None, description="path to the Modelfile")
+
+
+class OllamaCreateModelResponseBody(OllamaEndpointResponseBody):
+    status: str = Field(None)

lionagi/integrations/ollama_/api_endpoints/model/delete_model.py

@@ -0,0 +1,11 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pydantic import Field
+
+from ..data_models import OllamaEndpointRequestBody
+
+
+class OllamaDeleteModelRequestBody(OllamaEndpointRequestBody):
+    name: str = Field(description="Name of the model to delete")