mirascope 2.0.0a4__py3-none-any.whl → 2.0.0a6__py3-none-any.whl

mirascope/ops/__init__.py

@@ -2,117 +2,68 @@
 
 from __future__ import annotations
 
-try:
-    from ._internal.configuration import configure, tracer_context
-    from ._internal.context import propagated_context
-    from ._internal.instrumentation.llm import (
-        instrument_llm,
-        uninstrument_llm,
-    )
-    from ._internal.propagation import (
-        ContextPropagator,
-        PropagatorFormat,
-        extract_context,
-        get_propagator,
-        inject_context,
-        reset_propagator,
-    )
-    from ._internal.session import (
-        SESSION_HEADER_NAME,
-        SessionContext,
-        current_session,
-        extract_session_id,
-        session,
-    )
-    from ._internal.spans import Span, span
-    from ._internal.traced_calls import (
-        TracedAsyncCall,
-        TracedAsyncContextCall,
-        TracedCall,
-        TracedContextCall,
-    )
-    from ._internal.traced_functions import (
-        AsyncTrace,
-        AsyncTracedFunction,
-        Trace,
-        TracedFunction,
-    )
-    from ._internal.tracing import (
-        TraceDecorator,
-        trace,
-    )
-    from ._internal.versioned_calls import (
-        VersionedAsyncCall,
-        VersionedAsyncContextCall,
-        VersionedCall,
-        VersionedContextCall,
-    )
-    from ._internal.versioned_functions import (
-        AsyncVersionedFunction,
-        VersionedFunction,
-        VersionInfo,
-    )
-    from ._internal.versioning import (
-        VersionDecorator,
-        version,
-    )
-    from .exceptions import ClosureComputationError
+from .._stubs import stub_module_if_missing
 
-except ImportError:  # pragma: no cover
-    # TODO: refactor alongside other import error handling improvements
-    from collections.abc import Callable
-
-    def _create_otel_import_error_stub(name: str) -> Callable[..., None]:
-        """Create a stub that raises ImportError with helpful message."""
-
-        def _raise_not_installed() -> None:
-            raise ImportError(
-                f"The 'opentelemetry' packages are required to use {name}. "
-                "Install them with: `uv add 'mirascope[otel]'`."
-            )
-
-        return _raise_not_installed
-
-    propagated_context = _create_otel_import_error_stub("propagated_context")
-    instrument_llm = _create_otel_import_error_stub("instrument_llm")
-    uninstrument_llm = _create_otel_import_error_stub("uninstrument_llm")
-    ContextPropagator = _create_otel_import_error_stub("ContextPropagator")
-    PropagatorFormat = str
-    extract_context = _create_otel_import_error_stub("extract_context")
-    get_propagator = _create_otel_import_error_stub("get_propagator")
-    inject_context = _create_otel_import_error_stub("inject_context")
-    reset_propagator = _create_otel_import_error_stub("reset_propagator")
-    SESSION_HEADER_NAME = "X-Mirascope-Session-ID"
-    SessionContext = _create_otel_import_error_stub("SessionContext")
-    current_session = _create_otel_import_error_stub("current_session")
-    extract_session_id = _create_otel_import_error_stub("extract_session_id")
-    session = _create_otel_import_error_stub("session")
-    Span = _create_otel_import_error_stub("Span")
-    span = _create_otel_import_error_stub("span")
-    AsyncTrace = _create_otel_import_error_stub("AsyncTrace")
-    AsyncTracedFunction = _create_otel_import_error_stub("AsyncTracedFunction")
-    Trace = _create_otel_import_error_stub("Trace")
-    TraceDecorator = _create_otel_import_error_stub("TraceDecorator")
-    TracedAsyncCall = _create_otel_import_error_stub("TracedAsyncCall")
-    TracedAsyncContextCall = _create_otel_import_error_stub("TracedAsyncContextCall")
-    TracedCall = _create_otel_import_error_stub("TracedCall")
-    TracedContextCall = _create_otel_import_error_stub("TracedContextCall")
-    TracedFunction = _create_otel_import_error_stub("TracedFunction")
-    trace = _create_otel_import_error_stub("trace")
-    configure = _create_otel_import_error_stub("configure")
-    tracer_context = _create_otel_import_error_stub("tracer_context")
-    AsyncVersionedFunction = _create_otel_import_error_stub("AsyncVersionedFunction")
-    VersionDecorator = _create_otel_import_error_stub("VersionDecorator")
-    VersionedAsyncCall = _create_otel_import_error_stub("VersionedAsyncCall")
-    VersionedAsyncContextCall = _create_otel_import_error_stub(
-        "VersionedAsyncContextCall"
-    )
-    VersionedCall = _create_otel_import_error_stub("VersionedCall")
-    VersionedContextCall = _create_otel_import_error_stub("VersionedContextCall")
-    VersionedFunction = _create_otel_import_error_stub("VersionedFunction")
-    VersionInfo = _create_otel_import_error_stub("VersionInfo")
-    version = _create_otel_import_error_stub("version")
+# Stub modules for missing optional dependencies BEFORE importing
+# This must happen before any imports from these modules
+stub_module_if_missing("mirascope.ops", "ops")
 
+# Now imports work regardless of which packages are installed
+# ruff: noqa: E402
+from ._internal.configuration import configure, tracer_context
+from ._internal.context import propagated_context
+from ._internal.instrumentation.llm import (
+    instrument_llm,
+    uninstrument_llm,
+)
+from ._internal.propagation import (
+    ContextPropagator,
+    PropagatorFormat,
+    extract_context,
+    get_propagator,
+    inject_context,
+    reset_propagator,
+)
+from ._internal.session import (
+    SESSION_HEADER_NAME,
+    SessionContext,
+    current_session,
+    extract_session_id,
+    session,
+)
+from ._internal.spans import Span, span
+from ._internal.traced_calls import (
+    TracedAsyncCall,
+    TracedAsyncContextCall,
+    TracedCall,
+    TracedContextCall,
+)
+from ._internal.traced_functions import (
+    AsyncTrace,
+    AsyncTracedFunction,
+    Trace,
+    TracedFunction,
+)
+from ._internal.tracing import (
+    TraceDecorator,
+    trace,
+)
+from ._internal.versioned_calls import (
+    VersionedAsyncCall,
+    VersionedAsyncContextCall,
+    VersionedCall,
+    VersionedContextCall,
+)
+from ._internal.versioned_functions import (
+    AsyncVersionedFunction,
+    VersionedFunction,
+    VersionInfo,
+)
+from ._internal.versioning import (
+    VersionDecorator,
+    version,
+)
+from .exceptions import ClosureComputationError
 
 __all__ = [
     "SESSION_HEADER_NAME",

mirascope/ops/_internal/closure.py

@@ -50,6 +50,55 @@ def _is_third_party(module: ModuleType, site_packages: set[str]) -> bool:
     )
 
 
+class _RemoveVersionDecoratorTransformer(cst.CSTTransformer):
+    """CST transformer to remove @ops.version and @version decorators."""
+
+    @classmethod
+    def _is_version_decorator(cls, decorator: cst.Decorator) -> bool:
+        """Returns True if the decorator is @version or @ops.version."""
+        decorator_node = decorator.decorator
+
+        if isinstance(decorator_node, cst.Name) and decorator_node.value == "version":
+            return True
+        if (
+            isinstance(decorator_node, cst.Call)
+            and isinstance(decorator_node.func, cst.Name)
+            and decorator_node.func.value == "version"
+        ):
+            return True
+
+        if (
+            isinstance(decorator_node, cst.Attribute)
+            and isinstance(decorator_node.value, cst.Name)
+            and decorator_node.value.value == "ops"
+            and decorator_node.attr.value == "version"
+        ):
+            return True
+        if isinstance(decorator_node, cst.Call) and isinstance(
+            decorator_node.func, cst.Attribute
+        ):
+            func_attribute = decorator_node.func
+            if (
+                isinstance(func_attribute.value, cst.Name)
+                and func_attribute.value.value == "ops"
+                and func_attribute.attr.value == "version"
+            ):
+                return True
+
+        return False
+
+    def leave_FunctionDef(
+        self, original_node: cst.FunctionDef, updated_node: cst.FunctionDef
+    ) -> cst.FunctionDef:
+        """Returns function definition with @version/@ops.version decorators removed."""
+        new_decorators = [
+            decorator
+            for decorator in updated_node.decorators
+            if not self._is_version_decorator(decorator)
+        ]
+        return updated_node.with_changes(decorators=new_decorators)
+
+
 class _RemoveDocstringTransformer(cst.CSTTransformer):
     """CST transformer to remove docstrings from functions and classes."""
 
@@ -125,14 +174,9 @@ def _clean_source_code(
     if docstr_flag in ("1", "true", "yes"):
         return source.rstrip()
     module = cst.parse_module(source)
-
-    transformer = _RemoveDocstringTransformer(exclude_fn_body=exclude_fn_body)
-    new_module = module.visit(transformer)
-
-    code = new_module.code
-    code = code.rstrip()
-
-    return code
+    module = module.visit(_RemoveVersionDecoratorTransformer())
+    module = module.visit(_RemoveDocstringTransformer(exclude_fn_body=exclude_fn_body))
+    return module.code.rstrip()
 
 
 @dataclass(frozen=True)
@@ -596,9 +640,9 @@ def _clean_source_from_string(source: str, exclude_fn_body: bool = False) -> str
     """Returns cleaned source code string with optional docstring removal."""
     source = dedent(source)
     module = cst.parse_module(source)
-    transformer = _RemoveDocstringTransformer(exclude_fn_body=exclude_fn_body)
-    new_module = module.visit(transformer)
-    return new_module.code.rstrip()
+    module = module.visit(_RemoveVersionDecoratorTransformer())
+    module = module.visit(_RemoveDocstringTransformer(exclude_fn_body=exclude_fn_body))
+    return module.code.rstrip()
 
 
 def _get_class_source_from_method(method: Callable[..., Any]) -> str:
@@ -694,6 +738,13 @@ class _DependencyCollector:
             # For Python 3.13+
             return definition.func  # pyright: ignore[reportFunctionMemberAccess] # pragma: no cover
 
+        if (
+            (wrapped_function := getattr(definition, "fn", None)) is not None
+            and not hasattr(definition, "__qualname__")
+            and callable(wrapped_function)
+        ):
+            return wrapped_function
+
         return definition
 
     def _get_source_code(self, definition: Callable[..., Any] | type) -> str | None:

mirascope/ops/_internal/instrumentation/llm/llm.py

@@ -21,7 +21,6 @@ from opentelemetry.semconv.attributes import (
 
 from .....llm.context import Context, DepsT
 from .....llm.formatting import Format, FormattableT
-from .....llm.formatting._utils import create_tool_schema
 from .....llm.messages import Message
 from .....llm.models import Model
 from .....llm.providers import Params, ProviderId
@@ -230,7 +229,7 @@ def _serialize_tool_definitions(
         tool_schemas = _collect_tool_schemas(tools)
 
     if isinstance(format, Format) and format.mode == "tool":
-        tool_schemas.append(create_tool_schema(format))
+        tool_schemas.append(format.create_tool_schema())
 
     if not tool_schemas:
         return None

mirascope/ops/_internal/traced_functions.py

@@ -15,6 +15,7 @@ from typing import (
 
 from opentelemetry.util.types import AttributeValue
 
+from ...api.client import get_async_client, get_sync_client
 from ...llm.context import Context, DepsT
 from ...llm.responses.root_response import RootResponse
 from .protocols import (
@@ -91,7 +92,16 @@ class Trace(_BaseTrace[R]):
         metadata: dict[str, Jsonable] | None = None,
     ) -> None:
         """Annotates the current trace span."""
-        raise NotImplementedError("Trace.annotate not yet implemented")
+        if self.span.span_id is None or self.span.trace_id is None:
+            return
+
+        get_sync_client().annotations.create(
+            otel_span_id=self.span.span_id,
+            otel_trace_id=self.span.trace_id,
+            label=label,
+            reasoning=reasoning,
+            metadata=metadata,
+        )
 
     def tag(self, *tags: str) -> None:
         """Adds given tags to the current trace span."""
@@ -113,12 +123,21 @@ class AsyncTrace(_BaseTrace[R]):
     async def annotate(
         self,
         *,
-        label: str | None = None,
-        data: dict[str, Jsonable] | None = None,
+        label: Literal["pass", "fail"],
         reasoning: str | None = None,
+        metadata: dict[str, Jsonable] | None = None,
     ) -> None:
         """Annotates the current trace span."""
-        raise NotImplementedError("AsyncTrace.annotate not yet implemented")
+        if self.span.span_id is None or self.span.trace_id is None:
+            return
+
+        await get_async_client().annotations.create(
+            otel_span_id=self.span.span_id,
+            otel_trace_id=self.span.trace_id,
+            label=label,
+            reasoning=reasoning,
+            metadata=metadata,
+        )
 
     async def tag(self, *tags: str) -> None:
         """Adds given tags to the current trace span."""

mirascope/ops/_internal/versioned_functions.py

@@ -7,8 +7,13 @@ from collections.abc import Generator, Mapping
 from contextlib import contextmanager
 from dataclasses import dataclass, field
 from functools import cached_property, lru_cache
-from typing import Any, NewType
+from typing import Any, NewType, cast
 
+from ...api._generated.errors.not_found_error import NotFoundError
+from ...api._generated.functions.types.functions_create_request_dependencies_value import (
+    FunctionsCreateRequestDependenciesValue,
+)
+from ...api.client import get_async_client, get_sync_client
 from ..exceptions import ClosureComputationError
 from .closure import Closure
 from .spans import Span
@@ -239,40 +244,43 @@ class VersionedFunction(_BaseVersionedFunction[P, R], BaseSyncTracedFunction[P,
         raise NotImplementedError("VersionedFunction.get_version not yet implemented")
 
     def _ensure_registration(self) -> str | None:
-        """Returns function UUID after ensuring registration with API.
-
-        TODO: Implement API client integration to:
-        1. Get sync client via `get_sync_client()`
-        2. Check if function exists by hash: `client.functions.get_function_by_hash(self.closure.hash)`
-        3. If not found, create new version: `client.functions.create_a_new_function_version(...)`
-        4. Return the function UUID
-
-        Example implementation (from lilypad):
-        ```python
+        """Returns function UUID after ensuring registration with API."""
         if self.closure is None:
             return None
         try:
             client = get_sync_client()
         except Exception as e:
-            logger.warning(f"Failed to get client for function registration: {e}")
+            logger.warning("Failed to get client for function registration: %s", e)
             return None
 
         try:
-            existing = client.functions.get_function_by_hash(self.closure.hash)
-            return existing.uuid_
+            existing = client.functions.findbyhash(self.closure.hash)
+            return existing.id
         except NotFoundError:
-            response = client.functions.create_a_new_function_version(
+            dependencies: dict[str, FunctionsCreateRequestDependenciesValue | None] = {
+                name: FunctionsCreateRequestDependenciesValue(
+                    version=dep_info["version"],
+                    extras=dep_info.get("extras"),
+                )
+                for name, dep_info in self.closure.dependencies.items()
+            }
+            response = client.functions.create(
                 code=self.closure.code,
                 hash=self.closure.hash,
-                name=self.closure.name,
                 signature=self.closure.signature,
-                dependencies=self.closure.dependencies,
+                signature_hash=self.closure.signature_hash,
+                name=self.name or self.closure.name,
+                description=self.closure.docstring,
+                tags=list(self.tags) if self.tags else None,
+                metadata=cast(dict[str, str | None], self.metadata)
+                if self.metadata
+                else None,
+                dependencies=dependencies if dependencies else None,
             )
-            return response.uuid_
-        ```
-        """
-        # TODO: Implement when API client is available
-        return None
+            return response.id
+        except Exception as e:
+            logger.warning("Failed to register function: %s", e)
+            return None
 
 
 @dataclass(kw_only=True)
@@ -310,37 +318,40 @@ class AsyncVersionedFunction(
         )
 
     async def _ensure_registration(self) -> str | None:
-        """Returns function UUID after ensuring registration with API.
-
-        TODO: Implement API client integration to:
-        1. Get async client via `get_async_client()`
-        2. Check if function exists by hash: `await client.functions.get_function_by_hash(self.closure.hash)`
-        3. If not found, create new version: `await client.functions.create_a_new_function_version(...)`
-        4. Return the function UUID
-
-        Example implementation (from lilypad):
-        ```python
+        """Returns function UUID after ensuring registration with API."""
         if self.closure is None:
             return None
         try:
             client = get_async_client()
         except Exception as e:
-            logger.warning(f"Failed to get client for function registration: {e}")
+            logger.warning("Failed to get client for function registration: %s", e)
             return None
 
         try:
-            existing = await client.functions.get_function_by_hash(self.closure.hash)
-            return existing.uuid_
+            existing = await client.functions.findbyhash(self.closure.hash)
+            return existing.id
         except NotFoundError:
-            response = await client.functions.create_a_new_function_version(
+            dependencies: dict[str, FunctionsCreateRequestDependenciesValue | None] = {
+                name: FunctionsCreateRequestDependenciesValue(
+                    version=dep_info["version"],
+                    extras=dep_info.get("extras"),
+                )
+                for name, dep_info in self.closure.dependencies.items()
+            }
+            response = await client.functions.create(
                 code=self.closure.code,
                 hash=self.closure.hash,
-                name=self.closure.name,
                 signature=self.closure.signature,
-                dependencies=self.closure.dependencies,
+                signature_hash=self.closure.signature_hash,
+                name=self.name or self.closure.name,
+                description=self.closure.docstring,
+                tags=list(self.tags) if self.tags else None,
+                metadata=cast(dict[str, str | None], self.metadata)
+                if self.metadata
+                else None,
+                dependencies=dependencies if dependencies else None,
             )
-            return response.uuid_
-        ```
-        """
-        # TODO: Implement when API client is available
-        return None
+            return response.id
+        except Exception as e:
+            logger.warning("Failed to register function: %s", e)
+            return None

{mirascope-2.0.0a4.dist-info → mirascope-2.0.0a6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mirascope
-Version: 2.0.0a4
+Version: 2.0.0a6
 Summary: LLM abstractions that aren't obstructions
 Project-URL: Homepage, https://mirascope.com
 Project-URL: Documentation, https://mirascope.com/docs/mirascope/v2
@@ -52,11 +52,11 @@ Requires-Dist: pydantic>=2.0.0
 Requires-Dist: typing-extensions>=4.10.0
 Provides-Extra: all
 Requires-Dist: anthropic<1.0,>=0.75.0; extra == 'all'
-Requires-Dist: google-genai<2,>=1.48.0; extra == 'all'
+Requires-Dist: google-genai<2,>=1.57.0; extra == 'all'
 Requires-Dist: libcst>=1.8.6; extra == 'all'
-Requires-Dist: mcp<2,>=1.0.0; extra == 'all'
+Requires-Dist: mcp<2,>=1.25.0; extra == 'all'
 Requires-Dist: mlx-lm<1,>=0.28.4; extra == 'all'
-Requires-Dist: openai<3,>=2.7.1; extra == 'all'
+Requires-Dist: openai<3,>=2.14.0; extra == 'all'
 Requires-Dist: opentelemetry-api<2,>=1.38.0; extra == 'all'
 Requires-Dist: opentelemetry-exporter-otlp<2,>=1.38.0; extra == 'all'
 Requires-Dist: opentelemetry-instrumentation<1,>=0.59b0; extra == 'all'
@@ -74,15 +74,15 @@ Requires-Dist: anthropic<1.0,>=0.75.0; extra == 'anthropic'
 Provides-Extra: api
 Requires-Dist: pydantic-settings>=2.12.0; extra == 'api'
 Provides-Extra: google
-Requires-Dist: google-genai<2,>=1.48.0; extra == 'google'
+Requires-Dist: google-genai<2,>=1.57.0; extra == 'google'
 Requires-Dist: pillow<11,>=10.4.0; extra == 'google'
 Requires-Dist: proto-plus>=1.24.0; extra == 'google'
 Provides-Extra: mcp
-Requires-Dist: mcp<2,>=1.0.0; extra == 'mcp'
+Requires-Dist: mcp<2,>=1.25.0; extra == 'mcp'
 Provides-Extra: mlx
 Requires-Dist: mlx-lm<1,>=0.28.4; extra == 'mlx'
 Provides-Extra: openai
-Requires-Dist: openai<3,>=2.7.1; extra == 'openai'
+Requires-Dist: openai<3,>=2.14.0; extra == 'openai'
 Provides-Extra: ops
 Requires-Dist: libcst>=1.8.6; extra == 'ops'
 Requires-Dist: opentelemetry-api<2,>=1.38.0; extra == 'ops'