mirascope 1.0.5__py3-none-any.whl → 2.1.1__py3-none-any.whl

mirascope/beta/rag/weaviate/types.py

@@ -1,92 +0,0 @@
-"""Types for interacting with Weaviate using Mirascope."""
-
-from __future__ import annotations
-
-from typing import Any, Literal
-
-import weaviate.types as wt
-from pydantic import BaseModel, ConfigDict
-
-from ..base.document import Document
-from ..base.vectorstore_params import BaseVectorStoreParams
-
-
-class WeaviateSettings(BaseModel):
-    mode: Literal["local", "cloud", "custom", "embedded"] = "local"
-    headers: dict[str, str] | None = None
-    cluster_url: str | None = None
-    auth_credentials: Any | None = None
-    hostname: str | None = None
-    port: int | None = None
-    grpc_port: int | None = None
-    additional_config: Any | None = None
-    version: str | None = None
-    persistence_data_path: str | None = None
-    binary_path: str | None = None
-    environment_variables: dict[str, str] | None = None
-    http_host: str | None = None
-    http_port: int | None = None
-    http_secure: bool | None = None
-    grpc_host: str | None = None
-    grpc_secure: bool | None = None
-
-    skip_init_checks: bool | None = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    def kwargs(self) -> dict[str, Any]:
-        kwargs = {}
-        exclude = {"mode"}
-        if self.auth_credentials:
-            kwargs["auth_credentials"] = self.auth_credentials
-            exclude.add("auth_credentials")
-        if self.additional_config:
-            kwargs["additional_config"] = self.additional_config
-            exclude.add("additional_config")
-        additional_kwargs = {
-            key: value
-            for key, value in self.model_dump(exclude=exclude).items()
-            if value is not None
-        }
-        kwargs.update(additional_kwargs)
-        return kwargs
-
-
-class WeaviateParams(BaseVectorStoreParams):
-    vectorizer_config: Any | None = None
-    generative_config: Any | None = None
-
-    def kwargs(self) -> dict[str, Any]:
-        kwargs = {}
-        exclude = set()
-        if self.vectorizer_config:
-            kwargs["vectorizer_config"] = self.vectorizer_config
-            exclude = {"vectorizer_config"}
-        additional_kwargs = {
-            key: value
-            for key, value in self.model_dump(exclude=exclude).items()
-            if value is not None
-        }
-        kwargs.update(additional_kwargs)
-        return kwargs
-
-
-class WeaviateQueryResult(BaseModel):
-    id: wt.UUID
-    documents: list[Document] | None
-    metadata: dict[str, Any]
-    collection: str | None = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    def from_response(response_object) -> WeaviateQueryResult:
-        model_dict = {}
-        id = str(response_object.uuid)
-        text = response_object.properties["text"]
-        model_dict["id"] = id
-        doc = Document(id=id, text=text)
-        model_dict["documents"] = [doc]
-        model_dict["metadata"] = response_object.metadata.__dict__
-        model_dict["collection"] = response_object.collection
-
-        return WeaviateQueryResult.model_validate(model_dict)

mirascope/beta/rag/weaviate/vectorstores.py

@@ -1,103 +0,0 @@
-from functools import cached_property
-from typing import Any, ClassVar
-
-import weaviate
-import weaviate.classes as wvc
-from weaviate import WeaviateClient
-from weaviate.collections.collection import Collection
-
-from ..base.document import Document
-from ..base.vectorstores import BaseVectorStore
-from .types import (
-    WeaviateParams,
-    WeaviateQueryResult,
-    WeaviateSettings,
-)
-
-
-class WeaviateVectorStore(BaseVectorStore):
-    """A vectorstore for Weaviate.
-
-    Example:
-
-    ```python
-    from mirascope.beta.rag.weaviate.types import WeaviateSettings, WeaviateParams
-    from mirascope.beta.rag.weaviate import WeaviateVectorStore
-    from mirascope.beta.rag import TextChunker
-
-
-    class MyStore(WeaviateVectorStore):
-        chunker = TextChunker(chunk_size=1000, chunk_overlap=200)
-        index_name = "my-store-0001"
-        client_settings = WeaviateSettings()
-
-    my_store = MyStore()
-    with open(f"{PATH_TO_FILE}") as file:
-        data = file.read()
-        my_store.add(data)
-    properties = my_store.retrieve("my question").properties
-    print(documents)
-    """
-
-    _provider: ClassVar[str] = "weaviate"
-    vectorstore_params = WeaviateParams()
-    client_settings: ClassVar[WeaviateSettings] = WeaviateSettings()
-
-    def add(self, text: str | list[Document], **kwargs: Any) -> None:  # noqa: ANN401
-        """Takes unstructured data and inserts into vectorstore"""
-        documents: list[Document]
-        if isinstance(text, str):
-            chunk = self.chunker.chunk
-            documents = chunk(text)
-        else:
-            documents = text
-
-        if len(documents) < 2:
-            return self._index.data.insert(
-                properties={"text": documents[0].text}, uuid=documents[0].id, **kwargs
-            )
-
-        data_objects = []
-        for document in documents:
-            data_object = wvc.data.DataObject(
-                properties={"text": document.text}, uuid=document.id
-            )
-            data_objects.append(data_object)
-
-        return self._index.data.insert_many(data_objects)
-
-    def retrieve(self, text: str, **kwargs: Any) -> WeaviateQueryResult:  # noqa: ANN401
-        """Queries the vectorstore for closest match"""
-        query_result = self._index.query.near_text(query=text, **kwargs)
-        result = query_result.objects[0]
-
-        return WeaviateQueryResult.from_response(result)
-
-    def close_connection(self) -> None:
-        self._client.close()
-
-    ############################# PRIVATE PROPERTIES #################################
-
-    @cached_property
-    def _client(self) -> WeaviateClient:
-        if self.client_settings.mode == "local":
-            return weaviate.connect_to_local(**self.client_settings.kwargs())
-        elif self.client_settings.mode == "embedded":
-            return weaviate.connect_to_embedded(**self.client_settings.kwargs())
-        elif self.client_settings.mode == "cloud":
-            return weaviate.connect_to_weaviate_cloud(**self.client_settings.kwargs())
-        elif self.client_settings.mode == "custom":
-            return weaviate.connect_to_custom(**self.client_settings.kwargs())
-
-    @cached_property
-    def _index(self) -> Collection:
-        vectorstore_params = self.vectorstore_params
-
-        if self.index_name:
-            vectorstore_params = self.vectorstore_params.model_copy(
-                update={"name": self.index_name}
-            )
-        if self._client.collections.exists(self.index_name):
-            return self._client.collections.get(self.index_name)
-
-        return self._client.collections.create(**vectorstore_params.kwargs())

mirascope/core/__init__.py

@@ -1,55 +0,0 @@
-"""The Mirascope Core Functionality."""
-
-from contextlib import suppress
-
-from . import base
-from .base import (
-    BaseMessageParam,
-    BasePrompt,
-    BaseTool,
-    BaseToolKit,
-    metadata,
-    prompt_template,
-    toolkit_tool,
-)
-
-with suppress(ImportError):
-    from . import anthropic as anthropic
-
-with suppress(ImportError):
-    from . import cohere as cohere
-
-with suppress(ImportError):
-    from . import gemini as gemini
-
-with suppress(ImportError):
-    from . import groq as groq
-
-
-with suppress(ImportError):
-    from . import litellm as litellm
-
-
-with suppress(ImportError):
-    from . import mistral as mistral
-
-with suppress(ImportError):
-    from . import openai as openai
-
-__all__ = [
-    "anthropic",
-    "base",
-    "BaseMessageParam",
-    "BasePrompt",
-    "BaseTool",
-    "BaseToolKit",
-    "cohere",
-    "gemini",
-    "groq",
-    "litellm",
-    "metadata",
-    "mistral",
-    "openai",
-    "prompt_template",
-    "toolkit_tool",
-]

mirascope/core/anthropic/__init__.py

@@ -1,21 +0,0 @@
-"""The Mirascope Anthropic Module."""
-
-from ._call import anthropic_call
-from ._call import anthropic_call as call
-from .call_params import AnthropicCallParams
-from .call_response import AnthropicCallResponse
-from .call_response_chunk import AnthropicCallResponseChunk
-from .dynamic_config import AnthropicDynamicConfig
-from .stream import AnthropicStream
-from .tool import AnthropicTool
-
-__all__ = [
-    "call",
-    "AnthropicDynamicConfig",
-    "AnthropicCallParams",
-    "AnthropicCallResponse",
-    "AnthropicCallResponseChunk",
-    "AnthropicStream",
-    "AnthropicTool",
-    "anthropic_call",
-]

mirascope/core/anthropic/_call.py

@@ -1,71 +0,0 @@
-"""The `anthropic_call` decorator for functions as LLM calls."""
-
-from ..base import call_factory
-from ._utils import (
-    get_json_output,
-    handle_stream,
-    handle_stream_async,
-    setup_call,
-)
-from .call_params import AnthropicCallParams
-from .call_response import AnthropicCallResponse
-from .call_response_chunk import AnthropicCallResponseChunk
-from .dynamic_config import AnthropicDynamicConfig
-from .stream import AnthropicStream
-from .tool import AnthropicTool
-
-anthropic_call = call_factory(
-    TCallResponse=AnthropicCallResponse,
-    TCallResponseChunk=AnthropicCallResponseChunk,
-    TDynamicConfig=AnthropicDynamicConfig,
-    TStream=AnthropicStream,
-    TToolType=AnthropicTool,
-    TCallParams=AnthropicCallParams,
-    default_call_params=AnthropicCallParams(max_tokens=1000),
-    setup_call=setup_call,  # type: ignore
-    get_json_output=get_json_output,
-    handle_stream=handle_stream,
-    handle_stream_async=handle_stream_async,
-)
-"""A decorator for calling the Anthropic API with a typed function.
-
-usage docs: learn/calls.md
-
-This decorator is used to wrap a typed function that calls the Anthropic API. It
-parses the docstring of the wrapped function as the messages array and templates the
-input arguments for the function into each message's template.
-
-Example:
-
-```python
-from mirascope.core import prompt_template
-from mirascope.core.anthropic import anthropic_call
-
-
-@anthropic_call("claude-3-5-sonnet-20240620")
-@prompt_template("Recommend a {genre} book")
-def recommend_book(genre: str):
-    ...
-
-response = recommend_book("fantasy")
-print(response.content)
-```
-
-Args:
-    model (str): The Anthropic model to use in the API call.
-    stream (bool): Whether to stream the response from the API call.
-    tools (list[BaseTool | Callable]): The tools to use in the Anthropic API call.
-    response_model (BaseModel | BaseType): The response model into which the response
-        should be structured.
-    output_parser (Callable[[AnthropicCallResponse | ResponseModelT], Any]): A function
-        for parsing the call response whose value will be returned in place of the
-        original call response.
-    json_mode (bool): Whether to use JSON Mode.
-    client (object): An optional custom client to use in place of the default client.
-    call_params (AnthropicCallParams): The `AnthropicCallParams` call parameters to use
-        in the API call.
-
-Returns:
-    decorator (Callable): The decorator for turning a typed function into an Anthropic
-        API call.
-"""

mirascope/core/anthropic/_utils/__init__.py

@@ -1,16 +0,0 @@
-"""Anthropic utilities for decorator factories."""
-
-from ._calculate_cost import calculate_cost
-from ._convert_message_params import convert_message_params
-from ._get_json_output import get_json_output
-from ._handle_stream import handle_stream, handle_stream_async
-from ._setup_call import setup_call
-
-__all__ = [
-    "calculate_cost",
-    "convert_message_params",
-    "get_json_output",
-    "handle_stream",
-    "handle_stream_async",
-    "setup_call",
-]

mirascope/core/anthropic/_utils/_calculate_cost.py

@@ -1,63 +0,0 @@
-"""Calculate the cost of a completion using the Anthropic API."""
-
-
-def calculate_cost(
-    input_tokens: int | float | None,
-    output_tokens: int | float | None,
-    model: str = "claude-3-haiku-20240229",
-) -> float | None:
-    """Calculate the cost of a completion using the Anthropic API.
-
-    https://www.anthropic.com/api
-
-    claude-instant-1.2        $0.80 / 1M tokens   $2.40 / 1M tokens
-    claude-2.0                $8.00 / 1M tokens   $24.00 / 1M tokens
-    claude-2.1                $8.00 / 1M tokens   $24.00 / 1M tokens
-    claude-3-haiku            $0.25 / 1M tokens   $1.25 / 1M tokens
-    claude-3-sonnet           $3.00 / 1M tokens   $15.00 / 1M tokens
-    claude-3-opus             $15.00 / 1M tokens   $75.00 / 1M tokens
-    """
-    pricing = {
-        "claude-instant-1.2": {
-            "prompt": 0.000_000_8,
-            "completion": 0.000_002_4,
-        },
-        "claude-2.0": {
-            "prompt": 0.000_008,
-            "completion": 0.000_024,
-        },
-        "claude-2.1": {
-            "prompt": 0.000_008,
-            "completion": 0.000_024,
-        },
-        "claude-3-haiku-20240307": {
-            "prompt": 0.000_002_5,
-            "completion": 0.000_012_5,
-        },
-        "claude-3-sonnet-20240229": {
-            "prompt": 0.000_003,
-            "completion": 0.000_015,
-        },
-        "claude-3-opus-20240229": {
-            "prompt": 0.000_015,
-            "completion": 0.000_075,
-        },
-        "claude-3-5-sonnet-20240620": {
-            "prompt": 0.000_003,
-            "completion": 0.000_015,
-        },
-    }
-
-    if input_tokens is None or output_tokens is None:
-        return None
-
-    try:
-        model_pricing = pricing[model]
-    except KeyError:
-        return None
-
-    prompt_cost = input_tokens * model_pricing["prompt"]
-    completion_cost = output_tokens * model_pricing["completion"]
-    total_cost = prompt_cost + completion_cost
-
-    return total_cost

mirascope/core/anthropic/_utils/_convert_message_params.py

@@ -1,54 +0,0 @@
-"""Utility for converting `BaseMessageParam` to `MessageParam`"""
-
-import base64
-
-from anthropic.types import MessageParam
-
-from ...base import BaseMessageParam
-
-
-def convert_message_params(
-    message_params: list[BaseMessageParam | MessageParam],
-) -> list[MessageParam]:
-    converted_message_params = []
-    for message_param in message_params:
-        if not isinstance(message_param, BaseMessageParam):
-            converted_message_params.append(message_param)
-        elif isinstance(content := message_param.content, str):
-            converted_message_params.append(message_param.model_dump())
-        else:
-            converted_content = []
-            for part in content:
-                if part.type == "text":
-                    converted_content.append(part.model_dump())
-
-                elif part.type == "image":
-                    if part.media_type not in [
-                        "image/jpeg",
-                        "image/png",
-                        "image/gif",
-                        "image/webp",
-                    ]:
-                        raise ValueError(
-                            f"Unsupported image media type: {part.media_type}. Anthropic"
-                            " currently only supports JPEG, PNG, GIF, and WebP images."
-                        )
-                    converted_content.append(
-                        {
-                            "type": "image",
-                            "source": {
-                                "data": base64.b64encode(part.image).decode("utf-8"),
-                                "media_type": part.media_type,
-                                "type": "base64",
-                            },
-                        }
-                    )
-                else:
-                    raise ValueError(
-                        "Anthropic currently only supports text and image modalities. "
-                        f"Modality provided: {part.type}"
-                    )
-            converted_message_params.append(
-                {"role": message_param.role, "content": converted_content}
-            )
-    return converted_message_params

mirascope/core/anthropic/_utils/_get_json_output.py

@@ -1,34 +0,0 @@
-"""Get the JSON output from an anthropic call response or chunk."""
-
-import json
-
-from ..call_response import AnthropicCallResponse
-from ..call_response_chunk import AnthropicCallResponseChunk
-
-
-def get_json_output(
-    response: AnthropicCallResponse | AnthropicCallResponseChunk, json_mode: bool
-) -> str:
-    """Get the JSON output from a completion response."""
-    if isinstance(response, AnthropicCallResponse):
-        if json_mode and (content := response.content):
-            json_start = content.index("{")
-            json_end = content.rfind("}")
-            return content[json_start : json_end + 1]
-        elif (
-            (block := response.response.content[0])
-            and block.type == "tool_use"
-            and block.input is not None
-        ):
-            return json.dumps(block.input)
-        raise ValueError("No tool call or JSON object found in response.")
-    else:
-        if json_mode:
-            return response.content
-        elif (
-            response.chunk.type == "content_block_delta"
-            and (delta := response.chunk.delta)
-            and delta.type == "input_json_delta"
-        ):
-            return delta.partial_json
-        return ""

mirascope/core/anthropic/_utils/_handle_stream.py

@@ -1,89 +0,0 @@
-"""Utilities for handling a stream of messages."""
-
-from collections.abc import AsyncGenerator, Generator
-
-import jiter
-from anthropic.types import MessageStreamEvent, ToolUseBlock
-
-from ..call_response_chunk import AnthropicCallResponseChunk
-from ..tool import AnthropicTool
-
-
-def _handle_chunk(
-    buffer: str,
-    chunk: MessageStreamEvent,
-    current_tool_call: ToolUseBlock,
-    current_tool_type: type[AnthropicTool] | None,
-    tool_types: list[type[AnthropicTool]] | None,
-) -> tuple[
-    str,
-    AnthropicTool | None,
-    ToolUseBlock,
-    type[AnthropicTool] | None,
-]:
-    """Handles a chunk of the stream."""
-    if not tool_types:
-        return buffer, None, current_tool_call, current_tool_type
-
-    if chunk.type == "content_block_stop" and current_tool_type and buffer:
-        current_tool_call.input = jiter.from_json(buffer.encode())
-        return (
-            "",
-            current_tool_type.from_tool_call(current_tool_call),
-            ToolUseBlock(id="", input={}, name="", type="tool_use"),
-            None,
-        )
-
-    if chunk.type == "content_block_start" and isinstance(
-        chunk.content_block, ToolUseBlock
-    ):
-        content_block = chunk.content_block
-        current_tool_type = None
-        for tool_type in tool_types:
-            if tool_type._name() == content_block.name:
-                current_tool_type = tool_type
-                break
-        if current_tool_type is None:
-            raise RuntimeError(
-                f"Unknown tool type in stream: {content_block.name}."
-            )  # pragma: no cover
-        return (
-            "",
-            None,
-            ToolUseBlock(
-                id=content_block.id, input={}, name=content_block.name, type="tool_use"
-            ),
-            current_tool_type,
-        )
-
-    if chunk.type == "content_block_delta" and chunk.delta.type == "input_json_delta":
-        buffer += chunk.delta.partial_json
-
-    return buffer, None, current_tool_call, current_tool_type
-
-
-def handle_stream(
-    stream: Generator[MessageStreamEvent, None, None],
-    tool_types: list[type[AnthropicTool]] | None,
-) -> Generator[tuple[AnthropicCallResponseChunk, AnthropicTool | None], None, None]:
-    """Iterator over the stream and constructs tools as they are streamed."""
-    current_tool_call = ToolUseBlock(id="", input={}, name="", type="tool_use")
-    current_tool_type, buffer = None, ""
-    for chunk in stream:
-        buffer, tool, current_tool_call, current_tool_type = _handle_chunk(
-            buffer, chunk, current_tool_call, current_tool_type, tool_types
-        )
-        yield AnthropicCallResponseChunk(chunk=chunk), tool
-
-
-async def handle_stream_async(
-    stream: AsyncGenerator[MessageStreamEvent, None],
-    tool_types: list[type[AnthropicTool]] | None,
-) -> AsyncGenerator[tuple[AnthropicCallResponseChunk, AnthropicTool | None], None]:
-    current_tool_call = ToolUseBlock(id="", input={}, name="", type="tool_use")
-    current_tool_type, buffer = None, ""
-    async for chunk in stream:
-        buffer, tool, current_tool_call, current_tool_type = _handle_chunk(
-            buffer, chunk, current_tool_call, current_tool_type, tool_types
-        )
-        yield AnthropicCallResponseChunk(chunk=chunk), tool

mirascope/core/anthropic/_utils/_setup_call.py

@@ -1,76 +0,0 @@
-"""This module contains the setup_call function for the Anthropic API."""
-
-import inspect
-from collections.abc import Awaitable, Callable
-from typing import Any, cast
-
-from anthropic import (
-    Anthropic,
-    AnthropicBedrock,
-    AnthropicVertex,
-    AsyncAnthropic,
-    AsyncAnthropicBedrock,
-    AsyncAnthropicVertex,
-)
-from anthropic.types import Message, MessageParam
-
-from ...base import BaseMessageParam, BaseTool, _utils
-from ..call_params import AnthropicCallParams
-from ..dynamic_config import AnthropicDynamicConfig
-from ..tool import AnthropicTool
-from ._convert_message_params import convert_message_params
-
-
-def setup_call(
-    *,
-    model: str,
-    client: Anthropic
-    | AsyncAnthropic
-    | AnthropicBedrock
-    | AsyncAnthropicBedrock
-    | AnthropicVertex
-    | AsyncAnthropicVertex
-    | None,
-    fn: Callable[..., AnthropicDynamicConfig | Awaitable[AnthropicDynamicConfig]],
-    fn_args: dict[str, Any],
-    dynamic_config: AnthropicDynamicConfig,
-    tools: list[type[BaseTool] | Callable] | None,
-    json_mode: bool,
-    call_params: AnthropicCallParams,
-    extract: bool,
-) -> tuple[
-    Callable[..., Message] | Callable[..., Awaitable[Message]],
-    str,
-    list[MessageParam],
-    list[type[AnthropicTool]] | None,
-    dict[str, Any],
-]:
-    prompt_template, messages, tool_types, call_kwargs = _utils.setup_call(
-        fn, fn_args, dynamic_config, tools, AnthropicTool, call_params
-    )
-    messages = cast(list[BaseMessageParam | MessageParam], messages)
-    messages = convert_message_params(messages)
-
-    if messages[0]["role"] == "system":
-        call_kwargs["system"] = messages.pop(0)["content"]
-
-    if json_mode:
-        json_mode_content = _utils.json_mode_content(
-            tool_types[0] if tool_types else None
-        )
-        if isinstance(messages[-1]["content"], str):
-            messages[-1]["content"] += json_mode_content
-        else:
-            messages[-1]["content"] = list(messages[-1]["content"]) + [
-                {"type": "text", "text": json_mode_content}
-            ]
-        call_kwargs.pop("tools", None)
-    elif extract:
-        assert tool_types, "At least one tool must be provided for extraction."
-        call_kwargs["tool_choice"] = {"type": "tool", "name": tool_types[0]._name()}
-    call_kwargs |= {"model": model, "messages": messages}
-
-    if client is None:
-        client = AsyncAnthropic() if inspect.iscoroutinefunction(fn) else Anthropic()
-    create = client.messages.create
-    return create, prompt_template, messages, tool_types, call_kwargs