mirascope 1.25.5__tar.gz → 1.25.7__tar.gz

{mirascope-1.25.5 → mirascope-1.25.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mirascope
-Version: 1.25.5
+Version: 1.25.7
 Summary: LLM abstractions that aren't obstructions
 Project-URL: Homepage, https://mirascope.com
 Project-URL: Documentation, https://mirascope.com/WELCOME

{mirascope-1.25.5 → mirascope-1.25.7}/mirascope/beta/rag/chroma/types.py

@@ -2,9 +2,9 @@
 
 from typing import Any, Literal
 
-from chromadb import CollectionMetadata, Settings
+from chromadb import CollectionMetadata
 from chromadb.api.types import URI, Document, IDs, Loadable, Metadata
-from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT
+from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT, Settings
 from chromadb.types import Vector
 from pydantic import BaseModel, ConfigDict
 
@@ -29,7 +29,7 @@ class ChromaQueryResult(BaseModel):
 
 
 class ChromaSettings(BaseModel):
-    mode: Literal["http", "persistent", "ephemeral"] = "persistent"
+    mode: Literal["http", "persistent", "ephemeral", "cloud"] = "persistent"
     path: str = "./chroma"
     host: str = "localhost"
     port: int = 8000
@@ -38,17 +38,22 @@ class ChromaSettings(BaseModel):
     settings: Settings | None = None
     tenant: str = DEFAULT_TENANT
     database: str = DEFAULT_DATABASE
+    api_key: str | None = None
 
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
     def kwargs(self) -> dict[str, Any]:
         """Returns all parameters for the index as a keyword arguments dictionary."""
         if self.mode == "http":
-            exclude = {"mode", "path"}
+            exclude = {"mode", "path", "api_key"}
         elif self.mode == "persistent":
-            exclude = {"mode", "host", "port", "ssl", "headers"}
+            exclude = {"mode", "host", "port", "ssl", "headers", "api_key"}
         elif self.mode == "ephemeral":
-            exclude = {"mode", "host", "port", "ssl", "headers", "path"}
+            exclude = {"mode", "host", "port", "ssl", "headers", "path", "api_key"}
+        elif self.mode == "cloud":
+            exclude = {"mode", "path", "host", "port", "ssl", "headers"}
+        else:
+            exclude = {"mode"}
         kwargs = {
             key: value
             for key, value in self.model_dump(exclude=exclude).items()

{mirascope-1.25.5 → mirascope-1.25.7}/mirascope/beta/rag/chroma/vectorstores.py

@@ -3,7 +3,14 @@
 from functools import cached_property
 from typing import Any, ClassVar, cast
 
-from chromadb import Collection, EphemeralClient, HttpClient, Metadata, PersistentClient
+from chromadb import (
+    CloudClient,
+    Collection,
+    EphemeralClient,
+    HttpClient,
+    Metadata,
+    PersistentClient,
+)
 from chromadb.api import ClientAPI
 
 from ..base.document import Document
@@ -22,12 +29,25 @@ class ChromaVectorStore(BaseVectorStore):
     from mirascope.beta.rag import TextChunker
 
 
+    # Local persistent storage
     class MyStore(ChromaVectorStore):
         embedder = OpenAIEmbedder()
         chunker = TextChunker(chunk_size=1000, chunk_overlap=200)
         index_name = "my-store-0001"
         client_settings = ChromaSettings()
 
+    # Cloud mode with CloudClient authentication
+    class MyCloudStore(ChromaVectorStore):
+        embedder = OpenAIEmbedder()
+        chunker = TextChunker(chunk_size=1000, chunk_overlap=200)
+        index_name = "my-cloud-store-0001"
+        client_settings = ChromaSettings(
+            mode="cloud",
+            api_key="your-api-key",
+            tenant="your-tenant",
+            database="your-database",
+        )
+
     my_store = MyStore()
     with open(f"{PATH_TO_FILE}") as file:
         data = file.read()
@@ -82,6 +102,10 @@ class ChromaVectorStore(BaseVectorStore):
             return HttpClient(**self.client_settings.kwargs())
         elif self.client_settings.mode == "ephemeral":
             return EphemeralClient(**self.client_settings.kwargs())
+        elif self.client_settings.mode == "cloud":
+            return CloudClient(**self.client_settings.kwargs())
+        else:
+            raise ValueError(f"Unsupported client mode: {self.client_settings.mode}")
 
     @cached_property
     def _index(self) -> Collection:
@@ -93,5 +117,5 @@ class ChromaVectorStore(BaseVectorStore):
 
         return self._client.create_collection(
             **vectorstore_params.kwargs(),
-            embedding_function=self.embedder,
+            embedding_function=self.embedder,  # type: ignore[arg-type]
         )

{mirascope-1.25.5 → mirascope-1.25.7}/mirascope/core/anthropic/_utils/_message_param_converter.py

@@ -1,4 +1,5 @@
 import base64
+import logging
 from os import PathLike
 from typing import cast
 
@@ -17,6 +18,8 @@ from mirascope.core.base._utils._base_message_param_converter import (
     BaseMessageParamConverter,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class AnthropicMessageParamConverter(BaseMessageParamConverter):
     """Converts between Anthropic `MessageParam` objects and Mirascope `BaseMessageParam`."""
@@ -126,6 +129,15 @@ class AnthropicMessageParamConverter(BaseMessageParamConverter):
                             is_error=block.get("is_error", False),
                         )
                     )
+                elif block["type"] in [
+                    "thinking",
+                    "redacted_thinking",
+                ]:  # pragma: no cover
+                    logger.warning(
+                        "Dropping thinking content blocks as they are not supported at "
+                        "the provider agnostic level in v1. For native thinking support "
+                        "check out [v2](https://mirascope.com/docs/mirascope/v2)"
+                    )
                 else:
                     # Any other block type is not supported
                     raise ValueError(

{mirascope-1.25.5 → mirascope-1.25.7}/mirascope/core/mistral/_utils/_setup_call.py

@@ -39,6 +39,16 @@ from ..tool import MistralTool
 from ._convert_common_call_params import convert_common_call_params
 from ._convert_message_params import convert_message_params
 
+global_client: Mistral | None = None
+
+
+def _get_default_client() -> Mistral:
+    """Get or create the default Mistral client."""
+    global global_client
+    if global_client is None:
+        global_client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
+    return global_client
+
 
 @overload
 def setup_call(
@@ -144,7 +154,7 @@ def setup_call(
     call_kwargs |= {"model": model, "messages": messages}
 
     if client is None:
-        client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
+        client = _get_default_client()
     if fn_is_async(fn):
         create_or_stream = get_async_create_fn(
             client.chat.complete_async, client.chat.stream_async

{mirascope-1.25.5 → mirascope-1.25.7}/mirascope/retries/fallback.py

@@ -4,6 +4,7 @@ import inspect
 from collections.abc import Callable, Coroutine
 from typing import Any, ParamSpec, Protocol, TypeVar, overload
 
+from pydantic import BaseModel
 from typing_extensions import NotRequired, Required, TypedDict
 
 from .. import llm
@@ -75,8 +76,8 @@ def fallback(
     def decorator(
         fn: Callable[_P, _R] | Callable[_P, Coroutine[_R, Any, Any]],
     ) -> Callable[_P, _R] | Callable[_P, Coroutine[_R, Any, Any]]:
-        # TODO: figure out why llm call fn is not considered as coroutine at runtime
-        if inspect.iscoroutinefunction(fn._original_fn):  # pyright: ignore [reportFunctionMemberAccess]
+        fn_to_check = fn._original_fn if hasattr(fn, "_original_fn") else fn  # pyright: ignore [reportFunctionMemberAccess]
+        if inspect.iscoroutinefunction(fn_to_check):
 
             async def inner_async(*args: _P.args, **kwargs: _P.kwargs) -> _R:
                 caught: list[Exception] = []
@@ -86,15 +87,16 @@ def fallback(
                     caught.append(e)
                     for backup in fallbacks:
                         try:
-                            response = await llm.override(
-                                fn,
+                            with llm.context(
                                 provider=backup["provider"],
                                 model=backup["model"],
                                 call_params=backup.get("call_params", None),
                                 client=backup.get("client", None),
-                            )(*args, **kwargs)  # pyright: ignore [reportGeneralTypeIssues]
-                            response._caught = caught  # pyright: ignore [reportAttributeAccessIssue]
-                            return response  # pyright: ignore [reportReturnType]
+                            ):
+                                response = await fn(*args, **kwargs)  # pyright: ignore [reportGeneralTypeIssues]
+                                if isinstance(response, BaseModel):
+                                    response._caught = caught  # pyright: ignore [reportAttributeAccessIssue]
+                                return response  # pyright: ignore [reportReturnType]
                         except backup["catch"] as be:
                             caught.append(be)
                 raise FallbackError(f"All fallbacks failed:\n{caught}")
@@ -110,15 +112,16 @@ def fallback(
                     caught.append(e)
                     for backup in fallbacks:
                         try:
-                            response = llm.override(
-                                fn,
+                            with llm.context(
                                 provider=backup["provider"],
                                 model=backup["model"],
                                 call_params=backup.get("call_params", None),
                                 client=backup.get("client", None),
-                            )(*args, **kwargs)
-                            response._caught = caught  # pyright: ignore [reportAttributeAccessIssue]
-                            return response  # pyright: ignore [reportReturnType]
+                            ):
+                                response = fn(*args, **kwargs)
+                                if isinstance(response, BaseModel):
+                                    response._caught = caught  # pyright: ignore [reportAttributeAccessIssue]
+                                return response  # pyright: ignore [reportReturnType]
                         except backup["catch"] as be:
                             caught.append(be)
                 raise FallbackError(f"All fallbacks failed:\n{caught}")

{mirascope-1.25.5 → mirascope-1.25.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mirascope"
-version = "1.25.5"
+version = "1.25.7"
 description = "LLM abstractions that aren't obstructions"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -104,7 +104,7 @@ dev-dependencies = [
     "mkdocs-exclude>=1.0.2",
     "black>=24.8.0",
     "weaviate-client>=4.7.1",
-    "chromadb>=0.5.15",
+    "chromadb>=1.0.0",
     "pinecone-client>=5.0.1",
     "scikit-learn>=1.5.1",
     "duckduckgo-search>=6.2.10,<7",

mirascope-1.25.7/tests/retries/__init__.py

@@ -0,0 +1,4 @@
+import os
+
+os.environ["OPENAI_API_KEY"] = "test-key"
+os.environ["ANTHROPIC_API_KEY"] = "test-key"

mirascope-1.25.7/tests/retries/test_fallback.py

@@ -0,0 +1,286 @@
+"""Tests the `fallback` module."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from anthropic import RateLimitError as AnthropicRateLimitError
+from anthropic.types import (
+    Message,
+    MessageDeltaUsage,
+    RawContentBlockDeltaEvent,
+    RawContentBlockStartEvent,
+    RawContentBlockStopEvent,
+    RawMessageDeltaEvent,
+    RawMessageStartEvent,
+    RawMessageStopEvent,
+    TextBlock,
+    TextDelta,
+    Usage,
+)
+from anthropic.types.raw_message_delta_event import Delta
+from httpx import Request, Response
+from openai import RateLimitError as OpenAIRateLimitError
+
+from mirascope import llm
+from mirascope.retries.fallback import FallbackError, fallback
+
+
+@patch(
+    "anthropic.resources.messages.Messages.create",
+    new_callable=MagicMock,
+    side_effect=AnthropicRateLimitError(
+        message="",
+        response=Response(429, request=Request(method="", url="")),
+        body=None,
+    ),
+)
+@patch(
+    "openai.resources.chat.completions.Completions.create",
+    new_callable=MagicMock,
+    side_effect=OpenAIRateLimitError(
+        message="",
+        response=Response(429, request=Request(method="", url="")),
+        body=None,
+    ),
+)
+def test_fallback(mock_openai_create: MagicMock, mock_anthropic_create: MagicMock):
+    @fallback(
+        OpenAIRateLimitError,
+        [
+            {
+                "catch": AnthropicRateLimitError,
+                "provider": "anthropic",
+                "model": "claude-3-5-sonnet-latest",
+            }
+        ],
+    )
+    @llm.call("openai", "gpt-4o-mini")
+    def answer_question(question: str) -> str:
+        return question
+
+    with pytest.raises(FallbackError):
+        answer_question("What is the meaning of life?")
+
+
+@patch(
+    "anthropic.resources.messages.Messages.create",
+    new_callable=MagicMock,
+    return_value=Message(
+        id="id",
+        content=[TextBlock(text="content", type="text")],
+        model="claude-3-5-sonnet-20240620",
+        role="assistant",
+        stop_reason="end_turn",
+        stop_sequence=None,
+        type="message",
+        usage=Usage(input_tokens=1, output_tokens=1),
+    ),
+)
+@patch(
+    "openai.resources.chat.completions.Completions.create",
+    new_callable=MagicMock,
+    side_effect=OpenAIRateLimitError(
+        message="",
+        response=Response(429, request=Request(method="", url="")),
+        body=None,
+    ),
+)
+def test_fallback_success(
+    mock_openai_create: MagicMock, mock_anthropic_create: MagicMock
+):
+    @fallback(
+        OpenAIRateLimitError,
+        [
+            {
+                "catch": AnthropicRateLimitError,
+                "provider": "anthropic",
+                "model": "claude-3-5-sonnet-latest",
+            }
+        ],
+    )
+    @llm.call("openai", "gpt-4o-mini")
+    def answer_question(question: str) -> str:
+        return question
+
+    response = answer_question("What is the meaning of life?")
+    assert hasattr(response, "_caught")
+    assert isinstance(response._caught[0], OpenAIRateLimitError)
+
+
+@patch(
+    "anthropic.resources.messages.AsyncMessages.create",
+    new_callable=MagicMock,
+    side_effect=AnthropicRateLimitError(
+        message="",
+        response=Response(429, request=Request(method="", url="")),
+        body=None,
+    ),
+)
+@patch(
+    "openai.resources.chat.completions.AsyncCompletions.create",
+    new_callable=MagicMock,
+    side_effect=OpenAIRateLimitError(
+        message="",
+        response=Response(429, request=Request(method="", url="")),
+        body=None,
+    ),
+)
+@pytest.mark.asyncio
+async def test_fallback_async(
+    mock_openai_create: MagicMock, mock_anthropic_create: MagicMock
+):
+    @fallback(
+        OpenAIRateLimitError,
+        [
+            {
+                "catch": AnthropicRateLimitError,
+                "provider": "anthropic",
+                "model": "claude-3-5-sonnet-latest",
+            }
+        ],
+    )
+    @llm.call("openai", "gpt-4o-mini")
+    async def answer_question_async(question: str) -> str:
+        return question
+
+    with pytest.raises(FallbackError):
+        await answer_question_async("What is the meaning of life?")
+
+
+@patch(
+    "anthropic.resources.messages.AsyncMessages.create",
+    new_callable=MagicMock,
+)
+@patch(
+    "openai.resources.chat.completions.AsyncCompletions.create",
+    new_callable=MagicMock,
+    side_effect=OpenAIRateLimitError(
+        message="",
+        response=Response(429, request=Request(method="", url="")),
+        body=None,
+    ),
+)
+@pytest.mark.asyncio
+async def test_fallback_async_success(
+    mock_openai_call: AsyncMock, mock_anthropic_create: MagicMock
+):
+    async def awaitable_message():
+        return Message(
+            id="id",
+            content=[TextBlock(text="content", type="text")],
+            model="claude-3-5-sonnet-20240620",
+            role="assistant",
+            stop_reason="end_turn",
+            stop_sequence=None,
+            type="message",
+            usage=Usage(input_tokens=1, output_tokens=1),
+        )
+
+    mock_anthropic_create.return_value = awaitable_message()
+
+    @fallback(
+        OpenAIRateLimitError,
+        [
+            {
+                "catch": AnthropicRateLimitError,
+                "provider": "anthropic",
+                "model": "claude-3-5-sonnet-latest",
+            }
+        ],
+    )
+    @llm.call("openai", "gpt-4o-mini")
+    async def answer_question(question: str) -> str:
+        return question
+
+    response = await answer_question("What is the meaning of life?")
+    assert hasattr(response, "_caught")
+    assert isinstance(response._caught[0], OpenAIRateLimitError)
+
+
+@patch(
+    "anthropic.resources.messages.Messages.create",
+    new_callable=MagicMock,
+)
+@patch(
+    "openai.resources.chat.completions.Completions.create",
+    new_callable=MagicMock,
+)
+def test_fallback_streaming_wrapper(
+    mock_openai_create: MagicMock, mock_anthropic_create: MagicMock
+) -> None:
+    class StreamingError(Exception): ...
+
+    def failing_openai_generator():
+        """Generator that raises StreamingError when iterated"""
+        yield MagicMock()  # This will trigger the exception when next() is called
+        raise StreamingError("OpenAI streaming failed")
+
+    mock_openai_create.return_value = failing_openai_generator()
+    mock_anthropic_create.return_value = iter(
+        [
+            RawMessageStartEvent(
+                message=Message(
+                    id="msg_id",
+                    content=[],
+                    model="claude-3-5-sonnet-latest",
+                    role="assistant",
+                    stop_reason=None,
+                    stop_sequence=None,
+                    type="message",
+                    usage=Usage(input_tokens=10, output_tokens=0),
+                ),
+                type="message_start",
+            ),
+            RawContentBlockStartEvent(
+                content_block=TextBlock(
+                    text="",
+                    type="text",
+                ),
+                index=0,
+                type="content_block_start",
+            ),
+            RawContentBlockDeltaEvent(
+                delta=TextDelta(text="anthropic", type="text_delta"),
+                index=0,
+                type="content_block_delta",
+            ),
+            RawContentBlockDeltaEvent(
+                delta=TextDelta(text="streamed", type="text_delta"),
+                index=0,
+                type="content_block_delta",
+            ),
+            RawContentBlockDeltaEvent(
+                delta=TextDelta(text="successfully", type="text_delta"),
+                index=0,
+                type="content_block_delta",
+            ),
+            RawContentBlockStopEvent(index=0, type="content_block_stop"),
+            RawMessageDeltaEvent(
+                delta=Delta(stop_reason="end_turn", stop_sequence=None),
+                type="message_delta",
+                usage=MessageDeltaUsage(output_tokens=3),
+            ),
+            RawMessageStopEvent(type="message_stop"),
+        ]
+    )
+
+    @llm.call("openai", "gpt-4o-mini", stream=True)
+    def answer_question(question: str) -> str:
+        return question
+
+    @fallback(
+        StreamingError,
+        [
+            {
+                "catch": StreamingError,
+                "provider": "anthropic",
+                "model": "claude-3-5-sonnet-latest",
+            }
+        ],
+    )
+    def answer_question_wrapper(question: str) -> list[str]:
+        stream = answer_question("What is the meaning of life?")
+        return [chunk.content for chunk, _ in stream if chunk.content]
+
+    chunks = answer_question_wrapper("What is the meaning of life?")
+    assert chunks == ["anthropic", "streamed", "successfully"]