lionagi 0.5.4__py3-none-any.whl → 0.6.0__py3-none-any.whl

lionagi/integrations/ollama_/api_endpoints/api_request.py

@@ -1,179 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import json
-
-import aiohttp
-from pydantic import BaseModel, Field
-
-from .data_models import OllamaEndpointRequestBody
-from .match_response import match_response
-
-
-class OllamaRequest(BaseModel):
-    endpoint: str = Field(description="Endpoint for request")
-
-    method: str = Field(description="HTTP method")
-
-    @property
-    def base_url(self):
-        return "http://localhost:11434/api/"
-
-    async def invoke(
-        self,
-        json_data: OllamaEndpointRequestBody = None,
-        output_file: str = None,
-        with_response_header: bool = False,
-        parse_response: bool = True,
-    ):
-        url = self.base_url + self.endpoint
-        json_data = (
-            json_data.model_dump(exclude_unset=True) if json_data else None
-        )
-
-        async with aiohttp.ClientSession() as client:
-            async with client.request(
-                method=self.method, url=url, json=json_data
-            ) as response:
-                if response.status != 200:
-                    try:
-                        error_text = await response.json()
-                    except:
-                        error_text = await response.text()
-                    raise aiohttp.ClientResponseError(
-                        request_info=response.request_info,
-                        history=response.history,
-                        status=response.status,
-                        message=f"HTTP Error {response.status}. Response Body: {error_text}",
-                        headers=response.headers,
-                    )
-
-                # handle stream
-                if (
-                    response.headers.get("Content-Type")
-                    == "application/x-ndjson"
-                ):
-                    response_body = []
-                    file_handle = None
-                    if output_file:
-                        try:
-                            file_handle = open(output_file, "w")
-                        except Exception as e:
-                            raise ValueError(
-                                f"Invalid to output the response to {output_file}. Error:{e}"
-                            )
-                    try:
-                        async for chunk in response.content:
-                            chunk_str = chunk.decode("utf-8")
-                            chunk_str = chunk_str.strip()
-                            response_body.append(json.loads(chunk_str))
-                            if "status" in json.loads(chunk_str):
-                                print(json.loads(chunk_str))
-                            if file_handle:
-                                file_handle.write(chunk_str + "\n")
-
-                    finally:
-                        if file_handle:
-                            file_handle.close()
-
-                    if parse_response:
-                        response_body = match_response(self, response_body)
-                    if with_response_header:
-                        return response_body, response.headers
-                    else:
-                        return response_body
-                else:
-                    try:
-                        response_body = await response.json()
-                    except:
-                        response_body = await response.text()
-
-                    if output_file:
-                        try:
-                            with open(output_file, "wb") as f:
-                                f.write(await response.read())
-                        except Exception as e:
-                            raise ValueError(
-                                f"Invalid to output the response to {output_file}. Error:{e}"
-                            )
-
-                    if parse_response:
-                        response_body = match_response(self, response_body)
-                    if with_response_header:
-                        return response_body, response.headers
-                    else:
-                        return response_body
-
-    async def stream(
-        self,
-        json_data: OllamaEndpointRequestBody,
-        verbose: bool = True,
-        output_file: str = None,
-        with_response_header: bool = False,
-    ):
-
-        if not getattr(json_data, "stream", None):
-            raise ValueError(
-                "Request does not support stream or is not in stream mode. "
-                "Only requests with stream=True are supported."
-            )
-
-        url = self.base_url + self.endpoint
-        json_data = json_data.model_dump(exclude_unset=True)
-
-        async with aiohttp.ClientSession() as client:
-            async with client.request(
-                method=self.method, url=url, json=json_data
-            ) as response:
-                if response.status != 200:
-                    try:
-                        error_text = await response.json()
-                    except:
-                        error_text = await response.text()
-                    raise aiohttp.ClientResponseError(
-                        request_info=response.request_info,
-                        history=response.history,
-                        status=response.status,
-                        message=f"{error_text}",
-                        headers=response.headers,
-                    )
-
-                file_handle = None
-
-                if output_file:
-                    try:
-                        file_handle = open(output_file, "w")
-                    except Exception as e:
-                        raise ValueError(
-                            f"Invalid to output the response to {output_file}. Error:{e}"
-                        )
-
-                try:
-                    async for chunk in response.content:
-                        chunk_str = chunk.decode("utf-8")
-                        chunk_str = chunk_str.strip()
-                        if file_handle:
-                            file_handle.write(chunk_str + "\n")
-
-                        chunk_dict = json.loads(chunk_str)
-                        if verbose:
-                            if chunk_dict.get("response"):
-                                print(
-                                    chunk_dict.get("response"),
-                                    end="",
-                                    flush=True,
-                                )
-                            if message := chunk_dict.get("message"):
-                                print(
-                                    message.get("content"), end="", flush=True
-                                )
-
-                        yield chunk_dict
-
-                    if with_response_header:
-                        yield response.headers
-
-                finally:
-                    if file_handle:
-                        file_handle.close()

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

@@ -1,31 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from enum import Enum
-
-from pydantic import BaseModel, Field
-
-
-class Role(str, Enum):
-    SYSTEM = "system"
-    USER = "user"
-    ASSISTANT = "assistant"
-    TOOL = "tool"
-
-
-class Message(BaseModel):
-    role: Role = Field(
-        description="The role of the message, either 'system', 'user', 'assistant', or 'tool'"
-    )
-
-    content: str = Field(description="The content of the message")
-
-    images: list[str] | None = Field(
-        None,
-        description="a list of images to include in the message (for multimodal models such as 'llava')",
-    )
-
-    tool_calls: list | None = Field(
-        None, description="a list of tools the model wants to use"
-    )

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

@@ -1,46 +0,0 @@
-# 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

@@ -1,67 +0,0 @@
-# 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

@@ -1,49 +0,0 @@
-# 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

@@ -1,72 +0,0 @@
-# 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

@@ -1,59 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-# 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

@@ -1,62 +0,0 @@
-# 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."
-        )