mirascope 1.16.9__tar.gz → 1.17.0__tar.gz

mirascope-1.17.0/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: mirascope
+Version: 1.17.0
+Summary: LLM abstractions that aren't obstructions
+Project-URL: Homepage, https://mirascope.com
+Project-URL: Documentation, https://mirascope.com/WELCOME
+Project-URL: Repository, https://github.com/Mirascope/mirascope
+Project-URL: Issues, https://github.com/Mirascope/mirascope/issues
+Project-URL: Changelog, https://github.com/Mirascope/mirascope/releases
+Author-email: William Bakst <william@mirascope.com>, Brendan Kao <brendan@mirascope.com>
+Maintainer-email: William Bakst <william@mirascope.com>
+License: MIT License
+        
+        Copyright (c) 2023 Mirascope, Inc.
+        
+        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.
+License-File: LICENSE
+Keywords: agents,anthropic,artificial intelligence,bedrock,cohere,developer tools,gemini,groq,llm,llm tools,mistral,openai,prompt engineering,pydantic,vertex
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Pydantic :: 2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: File Formats :: JSON
+Classifier: Topic :: File Formats :: JSON :: JSON Schema
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: docstring-parser<1.0,>=0.15
+Requires-Dist: jiter>=0.5.0
+Requires-Dist: pydantic<3.0,>=2.7.4
+Requires-Dist: typing-extensions>=4.10.0
+Provides-Extra: anthropic
+Requires-Dist: anthropic<1.0,>=0.29.0; extra == 'anthropic'
+Provides-Extra: azure
+Requires-Dist: aiohttp<4.0,>=3.10.5; extra == 'azure'
+Requires-Dist: azure-ai-inference<2.0,>=1.0.0b4; extra == 'azure'
+Provides-Extra: bedrock
+Requires-Dist: aioboto3<14,>=13.1.1; extra == 'bedrock'
+Requires-Dist: boto3-stubs[bedrock-runtime]<2,>=1.35.32; extra == 'bedrock'
+Requires-Dist: boto3<2,>=1.34.70; extra == 'bedrock'
+Requires-Dist: types-aioboto3[bedrock-runtime]<14,>=13.1.1; extra == 'bedrock'
+Provides-Extra: cohere
+Requires-Dist: cohere<6,>=5.5.8; extra == 'cohere'
+Provides-Extra: gemini
+Requires-Dist: google-generativeai<1,>=0.4.0; extra == 'gemini'
+Requires-Dist: pillow<11,>=10.4.0; extra == 'gemini'
+Provides-Extra: groq
+Requires-Dist: groq<1,>=0.9.0; extra == 'groq'
+Provides-Extra: hyperdx
+Requires-Dist: hyperdx-opentelemetry<1,>=0.1.0; extra == 'hyperdx'
+Provides-Extra: langfuse
+Requires-Dist: langfuse<3,>=2.30.0; extra == 'langfuse'
+Provides-Extra: litellm
+Requires-Dist: litellm<2,>=1.42.12; extra == 'litellm'
+Provides-Extra: logfire
+Requires-Dist: logfire<4,>=1.0.0; extra == 'logfire'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0.0; extra == 'mcp'
+Provides-Extra: mistral
+Requires-Dist: mistralai<2,>=1.0.0; extra == 'mistral'
+Provides-Extra: openai
+Requires-Dist: openai<2,>=1.6.0; extra == 'openai'
+Provides-Extra: opentelemetry
+Requires-Dist: opentelemetry-api<2,>=1.22.0; extra == 'opentelemetry'
+Requires-Dist: opentelemetry-sdk<2,>=1.22.0; extra == 'opentelemetry'
+Provides-Extra: realtime
+Requires-Dist: numpy<2,>=1.26.4; extra == 'realtime'
+Requires-Dist: pydub<1,>=0.25.1; extra == 'realtime'
+Requires-Dist: sounddevice<1,>=0.5.1; extra == 'realtime'
+Requires-Dist: websockets<14,>=13.1; extra == 'realtime'
+Provides-Extra: tenacity
+Requires-Dist: tenacity<9,>=8.4.2; extra == 'tenacity'
+Provides-Extra: vertex
+Requires-Dist: google-cloud-aiplatform<2,>=1.38.0; extra == 'vertex'
+Description-Content-Type: text/markdown
+
+<div align="center" justiry="start">
+    <a href="https://mirascope.com">
+        <img align="bottom" src="https://github.com/Mirascope/mirascope/assets/99370834/e403d7ee-f8bc-4df1-b2d0-33763f021c89" alt="Frog Logo" width="84"/><br><img align="bottom" src="https://uploads-ssl.webflow.com/65a6fd6a1c3b2704d6217d3d/65b5674e9ceef563dc57eb11_Medium%20length%20hero%20headline%20goes%20here.svg" width="400" alt="Mirascope"/>
+    </a>
+</div>
+
+<p align="center">
+    <a href="https://github.com/Mirascope/mirascope/actions/workflows/tests.yml" target="_blank"><img src="https://github.com/Mirascope/mirascope/actions/workflows/tests.yml/badge.svg?branch=main" alt="Tests"/></a>
+    <a href="https://codecov.io/github/Mirascope/mirascope" target="_blank"><img src="https://codecov.io/github/Mirascope/mirascope/graph/badge.svg?token=HAEAWT3KC9" alt="Coverage"/></a>
+    <a href="https://mirascope.com/WELCOME" target="_blank"><img src="https://img.shields.io/badge/docs-available-brightgreen" alt="Docs"/></a>
+    <a href="https://pypi.python.org/pypi/mirascope" target="_blank"><img src="https://img.shields.io/pypi/v/mirascope.svg" alt="PyPI Version"/></a>
+    <a href="https://pypi.python.org/pypi/mirascope" target="_blank"><img src="https://img.shields.io/pypi/pyversions/mirascope.svg" alt="Stars"/></a>
+    <a href="https://github.com/Mirascope/mirascope/blog/dev/LICENSE"><img src="https://img.shields.io/github/license/Mirascope/mirascope.svg" alt="License"/></a>
+    <a href="https://github.com/Mirascope/mirascope/stargazers" target="_blank"><img src="https://img.shields.io/github/stars/Mirascope/mirascope.svg" alt="Stars"/></a>
+</p>
+
+---
+
+Mirascope is a powerful, flexible, and user-friendly library that simplifies the process of working with LLMs through a unified interface that works across various supported providers, including [OpenAI](https://openai.com/), [Anthropic](https://www.anthropic.com/), [Mistral](https://mistral.ai/), [Gemini](https://gemini.google.com), [Groq](https://groq.com/), [Cohere](https://cohere.com/), [LiteLLM](https://www.litellm.ai/), [Azure AI](https://azure.microsoft.com/en-us/solutions/ai), [Vertex AI](https://cloud.google.com/vertex-ai), and [Bedrock](https://aws.amazon.com/bedrock/).
+
+Whether you're generating text, extracting structured information, or developing complex AI-driven agent systems, Mirascope provides the tools you need to streamline your development process and create powerful, robust applications.
+
+## 30 Second Quickstart
+
+Install Mirascope, specifying the provider(s) you intend to use, and set your API key:
+
+```bash
+pip install "mirascope[openai]"
+export OPENAI_API_KEY=XXXXX
+```
+
+Make your first call to an LLM to extract the title and author of a book from unstructured text:
+
+```python
+from mirascope import llm
+from pydantic import BaseModel
+
+class Book(BaseModel):
+    title: str
+    author: str
+
+@llm.call(provider="openai", model="gpt-4o-mini", response_model=Book)
+def extract_book(text: str) -> str:
+    return f"Extract {text}"
+
+book = extract_book("The Name of the Wind by Patrick Rothfuss")
+assert isinstance(book, Book)
+print(book)
+# Output: title='The Name of the Wind' author='Patrick Rothfuss'
+```
+
+## Tutorials
+
+Check out our [quickstart tutorial](https://mirascope.com/tutorials/getting_started/quickstart) and many other tutorials for an interactive way to getting started with Mirascope.
+
+## Usage
+
+For a complete guide on how to use all of the various features Mirascope has to offer, read through our [Learn](https://mirascope.com/learn) documentation.
+
+## Versioning
+
+Mirascope uses [Semantic Versioning](https://semver.org/).
+
+## Licence
+
+This project is licensed under the terms of the [MIT License](https://github.com/Mirascope/mirascope/blob/dev/LICENSE).

mirascope-1.17.0/docs/learn/retries.md

@@ -0,0 +1,152 @@
+---
+search:
+  boost: 2
+---
+
+# Retries
+
+Making an API call to a provider can fail due to various reasons, such as rate limits, internal server errors, validation errors, and more. This makes retrying calls extremely important when building robust systems.
+
+Mirascope combined with [Tenacity](https://tenacity.readthedocs.io/en/latest/) increases the chance for these requests to succeed while maintaining end user transparency.
+
+You can install the necessary packages directly or use the `tenacity` extras flag:
+
+```python
+pip install "mirascope[tenacity]"
+```
+
+## Tenacity `retry` Decorator
+
+### Calls
+
+Let's take a look at a basic Mirascope call that retries with exponential back-off:
+
+!!! mira ""
+
+    {% for method, method_title in zip(prompt_writing_methods, prompt_writing_method_titles) %}
+    === "{{ method_title }}"
+
+        {% for provider in supported_llm_providers %}
+        === "{{ provider }}"
+
+            ```python hl_lines="2 5-8"
+            --8<-- "examples/learn/retries/calls/{{ provider | provider_dir }}/{{ method }}.py"
+            ```
+        {% endfor %}
+
+    {% endfor %}
+
+Ideally the call to `recommend_book` will succeed on the first attempt, but now the API call will be made again after waiting should it fail.
+
+The call will then throw a `RetryError` after 3 attempts if unsuccessful. This error should be caught and handled.
+
+### Streams
+
+When streaming, the generator is not actually run until you start iterating. This means the initial API call may be successful but fail during the actual iteration through the stream.
+
+Instead, you need to wrap your call and add retries to this wrapper:
+
+!!! mira ""
+
+    {% for method, method_title in zip(prompt_writing_methods, prompt_writing_method_titles) %}
+    === "{{ method_title }}"
+
+        {% for provider in supported_llm_providers %}
+        === "{{ provider }}"
+
+            ```python hl_lines="10-14"
+            --8<-- "examples/learn/retries/streams/{{ provider | provider_dir }}/{{ method }}.py"
+            ```
+        {% endfor %}
+
+    {% endfor %}
+
+### Tools
+
+When using tools, `ValidationError` errors won't happen until you attempt to construct the tool (either when calling `response.tools` or iterating through a stream with tools).
+
+You need to handle retries in this case the same way as streams:
+
+!!! mira ""
+
+    {% for method, method_title in zip(prompt_writing_methods, prompt_writing_method_titles) %}
+    === "{{ method_title }}"
+
+        {% for provider in supported_llm_providers %}
+        === "{{ provider }}"
+
+            ```python hl_lines="19-23"
+            --8<-- "examples/learn/retries/tools/{{ provider | provider_dir }}/{{ method }}.py"
+            ```
+        {% endfor %}
+
+    {% endfor %}
+
+### Error Reinsertion
+
+Every example above simply retries after a failed attempt without making any updates to the call. This approach can be sufficient for some use-cases where we can safely expect the call to succeed on subsequent attempts (e.g. rate limits).
+
+However, there are some cases where the LLM is likely to make the same mistake over and over again. For example, when using tools or response models, the LLM may return incorrect or missing arguments where it's highly likely the LLM will continuously make the same mistake on subsequent calls. In these cases, it's important that we update subsequent calls based on resulting errors to improve the chance of success on the next call.
+
+To make it easier to make such updates, Mirascope provides a `collect_errors` handler that can collect any errors of your choice and insert them into subsequent calls through an `errors` keyword argument.
+
+!!! mira ""
+
+    {% for method, method_title in zip(prompt_writing_methods, prompt_writing_method_titles) %}
+    === "{{ method_title }}"
+
+        {% for provider in supported_llm_providers %}
+        === "{{ provider }}"
+
+            {% if method == "string_template" %}
+            ```python hl_lines="4 14 27 42"
+            {% elif method == "shorthand" %}
+            ```python hl_lines="4 14 19 33"
+            {% else %}
+            ```python hl_lines="4 14 20 37"
+            {% endif %}
+            --8<-- "examples/learn/retries/error_reinsertion/{{ provider | provider_dir }}/{{ method }}.py"
+            ```
+        {% endfor %}
+
+    {% endfor %}
+
+In this example the first attempt fails because the identified author is not all uppercase. The `ValidationError` is then reinserted into the subsequent call, which enables the model to learn from it's mistake and correct its error.
+
+Of course, we could always engineer a better prompt (i.e. ask for all caps), but even prompt engineering does not guarantee perfect results. The purpose of this example is to demonstrate the power of a feedback loop by reinserting errors to build more robust systems.
+
+## Fallback
+
+When using the provider-agnostic `llm.call` decorator, you can use the `fallback` decorator to automatically catch certain errors and use a backup provider/model to attempt the call again.
+
+For example, we may want to attempt the call with Anthropic in the event that we get a `RateLimitError` from OpenAI:
+
+!!! mira ""
+
+    {% for method, method_title in zip(prompt_writing_methods, prompt_writing_method_titles) %}
+    === "{{ method_title }}"
+
+        ```python hl_lines="7-16 24 28"
+        --8<-- "examples/learn/retries/fallback/{{ method }}.py"
+        ```
+
+    {% endfor %}
+
+Here, we first attempt to call OpenAI (the default setting). If we catch the `OpenAIRateLimitError`, then we'll attempt to call Anthropic. If we catch the `AnthropicRateLimitError`, then we'll receive a `FallbackError` since all attempts failed.
+
+You can provide an `Exception` or tuple of multiple to catch, and you can stack the `fallback` decorator to handle different errors differently if desired.
+
+### Fallback With Retries
+
+The decorator also works well with Tenacity's `retry` decorator. For example, we may want to first attempt to call OpenAI multiple times with exponential backoff, but if we fail 3 times fall back to Anthropic, which we'll also attempt to call 3 times:
+
+!!! mira ""
+
+    {% for method, method_title in zip(prompt_writing_methods, prompt_writing_method_titles) %}
+    === "{{ method_title }}"
+
+        ```python hl_lines="14-28"
+        --8<-- "examples/learn/retries/fallback_retries/{{ method }}.py"
+        ```
+
+    {% endfor %}

mirascope-1.17.0/examples/learn/retries/fallback/base_message_param.py

@@ -0,0 +1,29 @@
+from anthropic import RateLimitError as AnthropicRateLimitError
+from mirascope import BaseMessageParam, llm
+from mirascope.retries import FallbackError, fallback
+from openai import RateLimitError as OpenAIRateLimitError
+
+
+@fallback(
+    OpenAIRateLimitError,
+    [
+        {
+            "catch": AnthropicRateLimitError,
+            "provider": "anthropic",
+            "model": "claude-3-5-sonnet-latest",
+        }
+    ],
+)
+@llm.call("openai", "gpt-4o-mini")
+def answer_question(question: str) -> list[BaseMessageParam]:
+    return [BaseMessageParam(role="user", content=f"Answer this question: {question}")]
+
+
+try:
+    response = answer_question("What is the meaning of life?")
+    if caught := getattr(response, "_caught", None):
+        print(f"Exception caught: {caught}")
+    print("### Response ###")
+    print(response.content)
+except FallbackError as e:
+    print(e)

mirascope-1.17.0/examples/learn/retries/fallback/messages.py

@@ -0,0 +1,29 @@
+from anthropic import RateLimitError as AnthropicRateLimitError
+from mirascope import Messages, llm
+from mirascope.retries import FallbackError, fallback
+from openai import RateLimitError as OpenAIRateLimitError
+
+
+@fallback(
+    OpenAIRateLimitError,
+    [
+        {
+            "catch": AnthropicRateLimitError,
+            "provider": "anthropic",
+            "model": "claude-3-5-sonnet-latest",
+        }
+    ],
+)
+@llm.call("openai", "gpt-4o-mini")
+def answer_question(question: str) -> Messages.Type:
+    return Messages.User(f"Answer this question: {question}")
+
+
+try:
+    response = answer_question("What is the meaning of life?")
+    if caught := getattr(response, "_caught", None):
+        print(f"Exception caught: {caught}")
+    print("### Response ###")
+    print(response.content)
+except FallbackError as e:
+    print(e)

mirascope-1.17.0/examples/learn/retries/fallback/shorthand.py

@@ -0,0 +1,29 @@
+from anthropic import RateLimitError as AnthropicRateLimitError
+from mirascope import llm
+from mirascope.retries import FallbackError, fallback
+from openai import RateLimitError as OpenAIRateLimitError
+
+
+@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 f"Answer this question: {question}"
+
+
+try:
+    response = answer_question("What is the meaning of life?")
+    if caught := getattr(response, "_caught", None):
+        print(f"Exception caught: {caught}")
+    print("### Response ###")
+    print(response.content)
+except FallbackError as e:
+    print(e)

mirascope-1.17.0/examples/learn/retries/fallback/string_template.py

@@ -0,0 +1,29 @@
+from anthropic import RateLimitError as AnthropicRateLimitError
+from mirascope import llm, prompt_template
+from mirascope.retries import FallbackError, fallback
+from openai import RateLimitError as OpenAIRateLimitError
+
+
+@fallback(
+    OpenAIRateLimitError,
+    [
+        {
+            "catch": AnthropicRateLimitError,
+            "provider": "anthropic",
+            "model": "claude-3-5-sonnet-latest",
+        }
+    ],
+)
+@llm.call("openai", "gpt-4o-mini")
+@prompt_template("Answer this question: {question}")
+def answer_question(question: str): ...
+
+
+try:
+    response = answer_question("What is the meaning of life?")
+    if caught := getattr(response, "_caught", None):
+        print(f"Exception caught: {caught}")
+    print("### Response ###")
+    print(response.content)
+except FallbackError as e:
+    print(e)

mirascope-1.17.0/examples/learn/retries/fallback_retries/base_message_param.py

@@ -0,0 +1,41 @@
+from anthropic import RateLimitError as AnthropicRateLimitError
+from mirascope import BaseMessageParam, llm
+from mirascope.retries import FallbackError, fallback
+from openai import RateLimitError as OpenAIRateLimitError
+from tenacity import (
+    RetryError,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+
+@fallback(
+    RetryError,
+    [
+        {
+            "catch": RetryError,
+            "provider": "anthropic",
+            "model": "claude-3-5-sonnet-latest",
+        }
+    ],
+)
+@retry(
+    retry=retry_if_exception_type((OpenAIRateLimitError, AnthropicRateLimitError)),
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=4, max=10),
+)
+@llm.call("openai", "gpt-4o-mini")
+def answer_question(question: str) -> list[BaseMessageParam]:
+    return [BaseMessageParam(role="user", content=f"Answer this question: {question}")]
+
+
+try:
+    response = answer_question("What is the meaning of life?")
+    if caught := getattr(response, "_caught", None):
+        print(f"Exception caught: {caught}")
+    print("### Response ###")
+    print(response.content)
+except FallbackError as e:
+    print(e)

mirascope-1.17.0/examples/learn/retries/fallback_retries/messages.py

@@ -0,0 +1,41 @@
+from anthropic import RateLimitError as AnthropicRateLimitError
+from mirascope import Messages, llm
+from mirascope.retries import FallbackError, fallback
+from openai import RateLimitError as OpenAIRateLimitError
+from tenacity import (
+    RetryError,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+
+@fallback(
+    RetryError,
+    [
+        {
+            "catch": RetryError,
+            "provider": "anthropic",
+            "model": "claude-3-5-sonnet-latest",
+        }
+    ],
+)
+@retry(
+    retry=retry_if_exception_type((OpenAIRateLimitError, AnthropicRateLimitError)),
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=4, max=10),
+)
+@llm.call("openai", "gpt-4o-mini")
+def answer_question(question: str) -> Messages.Type:
+    return Messages.User(f"Answer this question: {question}")
+
+
+try:
+    response = answer_question("What is the meaning of life?")
+    if caught := getattr(response, "_caught", None):
+        print(f"Exception caught: {caught}")
+    print("### Response ###")
+    print(response.content)
+except FallbackError as e:
+    print(e)

mirascope-1.17.0/examples/learn/retries/fallback_retries/shorthand.py

@@ -0,0 +1,41 @@
+from anthropic import RateLimitError as AnthropicRateLimitError
+from mirascope import llm
+from mirascope.retries import FallbackError, fallback
+from openai import RateLimitError as OpenAIRateLimitError
+from tenacity import (
+    RetryError,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+
+@fallback(
+    RetryError,
+    [
+        {
+            "catch": RetryError,
+            "provider": "anthropic",
+            "model": "claude-3-5-sonnet-latest",
+        }
+    ],
+)
+@retry(
+    retry=retry_if_exception_type((OpenAIRateLimitError, AnthropicRateLimitError)),
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=4, max=10),
+)
+@llm.call("openai", "gpt-4o-minis")
+def answer_question(question: str) -> str:
+    return f"Answer this question: {question}"
+
+
+try:
+    response = answer_question("What is the meaning of life?")
+    if caught := getattr(response, "_caught", None):
+        print(f"Exception caught: {caught}")
+    print("### Response ###")
+    print(response.content)
+except FallbackError as e:
+    print(e)

mirascope-1.17.0/examples/learn/retries/fallback_retries/string_template.py

@@ -0,0 +1,41 @@
+from anthropic import RateLimitError as AnthropicRateLimitError
+from mirascope import llm, prompt_template
+from mirascope.retries import FallbackError, fallback
+from openai import RateLimitError as OpenAIRateLimitError
+from tenacity import (
+    RetryError,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+
+@fallback(
+    RetryError,
+    [
+        {
+            "catch": RetryError,
+            "provider": "anthropic",
+            "model": "claude-3-5-sonnet-latest",
+        }
+    ],
+)
+@retry(
+    retry=retry_if_exception_type((OpenAIRateLimitError, AnthropicRateLimitError)),
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=4, max=10),
+)
+@llm.call("openai", "gpt-4o-mini")
+@prompt_template("Answer this question: {question}")
+def answer_question(question: str): ...
+
+
+try:
+    response = answer_question("What is the meaning of life?")
+    if caught := getattr(response, "_caught", None):
+        print(f"Exception caught: {caught}")
+    print("### Response ###")
+    print(response.content)
+except FallbackError as e:
+    print(e)

mirascope-1.17.0/mirascope/__init__.py

@@ -0,0 +1,36 @@
+"""Mirascope package."""
+
+import importlib.metadata
+from contextlib import suppress
+
+with suppress(ImportError):
+    from . import core as core
+
+from .core import (
+    BaseDynamicConfig,
+    BaseMessageParam,
+    BaseTool,
+    BaseToolKit,
+    Messages,
+    prompt_template,
+)
+
+with suppress(ImportError):
+    from . import integrations as integrations
+
+with suppress(ImportError):
+    from . import retries as retries
+
+__version__ = importlib.metadata.version("mirascope")
+
+__all__ = [
+    "BaseDynamicConfig",
+    "BaseMessageParam",
+    "BaseTool",
+    "BaseToolKit",
+    "core",
+    "integrations",
+    "prompt_template",
+    "retries",
+    "__version__",
+]