sentry-sdk 2.69.2__tar.gz → 2.70.0__tar.gz

{sentry_sdk-2.69.2/sentry_sdk.egg-info → sentry_sdk-2.70.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.69.2
+Version: 2.70.0
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors

{sentry_sdk-2.69.2 → sentry_sdk-2.70.0}/pyproject.toml

@@ -80,6 +80,7 @@ typing = [
     "tiktoken>=0.14.0",
     "aiohttp>=3.14.3",
     "openai-agents>=0.22.0",
+    "mistralai>=2.10.1",
 ]
 test = [
     "dataclasses ; python_full_version < '3.7'",

{sentry_sdk-2.69.2 → sentry_sdk-2.70.0}/sentry_sdk/_types.py

@@ -481,6 +481,14 @@ if TYPE_CHECKING:
         name: NotRequired[str]
         arguments: NotRequired[Any]
 
+    class InputMessage(TypedDict):
+        role: Literal["user", "assistant", "tool"]
+        parts: list[Union[TextPart, ReasoningPart, ToolCallPart]]
+
+    class OutputMessage(TypedDict):
+        role: Literal["assistant"]
+        parts: list[Union[TextPart, ReasoningPart]]
+
     class ToolDefinition(TypedDict):
         type: str
         name: NotRequired[str]

{sentry_sdk-2.69.2 → sentry_sdk-2.70.0}/sentry_sdk/consts.py

@@ -1316,6 +1316,7 @@ class ClientConstructor:
         transport_queue_size: int = DEFAULT_QUEUE_SIZE,
         sample_rate: float = 1.0,
         send_default_pii: "Optional[bool]" = None,
+        data_collection: "Optional[DataCollectionUserOptions]" = None,
         http_proxy: "Optional[str]" = None,
         https_proxy: "Optional[str]" = None,
         ignore_errors: "Sequence[Union[type, str]]" = [],  # noqa: B006
@@ -1472,6 +1473,23 @@ class ClientConstructor:
             If you enable this option, be sure to manually remove what you don't want to send using our features for
             managing `Sensitive Data <https://docs.sentry.io/data-management/sensitive-data/>`_.
 
+        :param data_collection: Structured configuration controlling what data integrations collect
+            automatically, superseding `send_default_pii`. Passing a dict opts into the feature; omitted
+            fields use their defaults (most categories are collected, with the sensitive denylist
+            scrubbing values). When it is not set, the SDK derives behaviour from `send_default_pii` so
+            that upgrading changes nothing. Restrict collection per category (user identity, cookies,
+            HTTP headers/bodies, query params, generative AI inputs/outputs, stack frame variables,
+            source context). If `send_default_pii` is also set, `data_collection` takes precedence.
+
+            Example::
+
+                sentry_sdk.init(
+                    dsn="...",
+                    data_collection={"user_info": False, "http_bodies": []},
+                )
+
+            See https://docs.sentry.io/platforms/python/configuration/options/#data_collection for more details.
+
         :param event_scrubber: Scrubs the event payload for sensitive information such as cookies, sessions, and
             passwords from a `denylist`.
 
@@ -1807,24 +1825,6 @@ class ClientConstructor:
             `trace_lifecycle="stream"` is enabled.
 
         :param _experiments: Dictionary of experimental, opt-in features that are not yet stable.
-
-            ``data_collection`` (EXPERIMENTAL): structured configuration controlling what data integrations
-            collect automatically, superseding `send_default_pii`. Passing a dict under
-            `_experiments={"data_collection": {...}}` opts into the feature; omitted fields use their
-            defaults (most categories are collected, with the sensitive denylist scrubbing values).
-            When it is not set, the SDK derives behaviour from `send_default_pii` so that upgrading
-            changes nothing. Restrict collection per category (user identity, cookies, HTTP
-            headers/bodies, query params, generative AI inputs/outputs, stack frame variables, source
-            context). If `send_default_pii` is also set, `data_collection` takes precedence.
-
-            Example::
-
-                sentry_sdk.init(
-                    dsn="...",
-                    _experiments={"data_collection": {"user_info": False, "http_bodies": []}},
-                )
-
-            See https://docs.sentry.io/platforms/python/configuration/options/#data_collection for more details.
         """
         pass
 
@@ -1848,4 +1848,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.69.2"
+VERSION = "2.70.0"

{sentry_sdk-2.69.2 → sentry_sdk-2.70.0}/sentry_sdk/data_collection.py

@@ -293,8 +293,15 @@ def _resolve_data_collection(options: "Dict[str, Any]") -> "DataCollection":
     concrete values for every field.
 
     ``data_collection`` must be a plain ``dict``.
+
+    Must be called exactly once per options dict, before ``client._get_options``
+    overwrites ``options["data_collection"]`` with the resolved result. Feeding an
+    already-resolved dict back in would flip ``provided_by_user`` to ``True``.
     """
-    user_dc = options.get("_experiments", {}).get("data_collection")
+    user_dc = options.get("data_collection")
+    if user_dc is None:
+        user_dc = options.get("_experiments", {}).get("data_collection")
+
     send_default_pii = options.get("send_default_pii")
 
     include_local_variables = (

{sentry_sdk-2.69.2 → sentry_sdk-2.70.0}/sentry_sdk/integrations/__init__.py

@@ -149,6 +149,7 @@ _MIN_VERSIONS = {
     "litellm": (1, 77, 5),
     "loguru": (0, 7, 0),
     "mcp": (1, 15, 0),
+    "mistral": (2, 0, 5),
     "openai": (1, 0, 0),
     "openai_agents": (0, 0, 19),
     "openfeature": (0, 7, 1),

sentry_sdk-2.70.0/sentry_sdk/integrations/mistral.py

@@ -0,0 +1,506 @@
+import json
+from collections.abc import Sequence
+from functools import wraps
+from typing import TYPE_CHECKING, cast
+
+import sentry_sdk
+from sentry_sdk.ai.utils import (
+    get_start_span_function,
+)
+from sentry_sdk.consts import OP, SPANDATA
+from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.scope import should_send_default_pii
+from sentry_sdk.tracing_utils import (
+    has_span_streaming_enabled,
+)
+from sentry_sdk.utils import has_data_collection_enabled
+
+if TYPE_CHECKING:
+    from typing import Any, Callable, Iterable, Optional, TypeGuard, Union
+
+    from mistralai.client.models import (
+        AssistantMessageTypedDict,
+        ChatCompletionRequestMessage,
+        ChatCompletionRequestMessageTypedDict,
+        SystemMessageTypedDict,
+        TextChunkTypedDict,
+    )
+
+    from sentry_sdk._types import InputMessage, OutputMessage, TextPart
+
+try:
+    from mistralai.client.chat import Chat
+    from mistralai.client.models import (
+        AssistantMessage,
+        ChatCompletionResponse,
+        SystemMessage,
+        TextChunk,
+        UserMessage,
+    )
+except ImportError:
+    raise DidNotEnable("mistralai not installed")
+
+
+class MistralIntegration(Integration):
+    identifier = "mistral"
+    origin = f"auto.ai.{identifier}"
+
+    @staticmethod
+    def setup_once() -> None:
+        Chat.complete = _wrap_complete(Chat.complete)  # type: ignore[method-assign]
+
+        Chat.complete_async = _wrap_complete_async(Chat.complete_async)  # type: ignore[method-assign]
+
+
+def _is_system_instruction(
+    message: "Union[ChatCompletionRequestMessage, ChatCompletionRequestMessageTypedDict]",
+) -> "TypeGuard[Union[SystemMessage, SystemMessageTypedDict]]":
+    if isinstance(message, SystemMessage):
+        return True
+
+    if isinstance(message, dict):
+        return message.get("role") == "system"
+
+    return False
+
+
+def _transform_input_messages(
+    messages: "Sequence[Union[ChatCompletionRequestMessage, ChatCompletionRequestMessageTypedDict]]",
+) -> "list[InputMessage]":
+    input_messages: "list[InputMessage]" = []
+
+    for message in messages:
+        if isinstance(message, UserMessage) and isinstance(message.content, str):
+            input_messages.append(
+                {
+                    "role": "user",
+                    "parts": [{"type": "text", "content": message.content}],
+                }
+            )
+        elif isinstance(message, UserMessage) and isinstance(message.content, list):
+            text_parts = [
+                part for part in message.content if isinstance(part, TextChunk)
+            ]
+            input_messages.append(
+                {
+                    "role": "user",
+                    "parts": [
+                        {"type": "text", "content": part.text} for part in text_parts
+                    ],
+                }
+            )
+
+        if isinstance(message, AssistantMessage) and isinstance(message.content, str):
+            input_messages.append(
+                {
+                    "role": "assistant",
+                    "parts": [{"type": "text", "content": message.content}],
+                }
+            )
+        elif isinstance(message, AssistantMessage) and isinstance(
+            message.content, list
+        ):
+            text_parts = [
+                part for part in message.content if isinstance(part, TextChunk)
+            ]
+            input_messages.append(
+                {
+                    "role": "assistant",
+                    "parts": [
+                        {"type": "text", "content": part.text} for part in text_parts
+                    ],
+                }
+            )
+
+        if not isinstance(message, dict):
+            continue
+
+        role = message.get("role")
+        if role != "user" and role != "assistant":
+            continue
+
+        content = message.get("content")
+        if isinstance(content, str):
+            input_messages.append(
+                {"role": role, "parts": [{"type": "text", "content": content}]}
+            )
+
+        if not isinstance(content, list):
+            continue
+
+        text_parts = [
+            part
+            for part in content
+            if isinstance(part, dict) and part.get("type") == "text" and "text" in part
+        ]
+        input_messages.append(
+            {
+                "role": role,
+                "parts": [
+                    {
+                        "type": "text",
+                        "content": cast("TextChunkTypedDict", part)["text"],
+                    }
+                    for part in text_parts
+                ],
+            }
+        )
+
+    return input_messages
+
+
+def _transform_output_message(
+    message: "Union[AssistantMessage, AssistantMessageTypedDict]",
+) -> "Optional[OutputMessage]":
+    if isinstance(message, AssistantMessage):
+        if message.content is None:
+            return None
+
+        if isinstance(message.content, str):
+            return {
+                "role": "assistant",
+                "parts": [{"type": "text", "content": message.content}],
+            }
+
+        parts = [part for part in message.content if isinstance(part, TextChunk)]
+        return {
+            "role": "assistant",
+            "parts": [{"type": "text", "content": part.text} for part in parts],
+        }
+
+    content = message.get("content")
+    if content is None:
+        return None
+
+    if isinstance(content, str):
+        return {"role": "assistant", "parts": [{"type": "text", "content": content}]}
+
+    text_parts = [
+        part
+        for part in content
+        if isinstance(part, dict) and part.get("type") == "text"
+    ]
+    return {
+        "role": "assistant",
+        "parts": [
+            {"type": "text", "content": cast("TextChunkTypedDict", part)["text"]}
+            for part in text_parts
+        ],
+    }
+
+
+def _transform_system_instructions(
+    messages: "list[Union[SystemMessage, SystemMessageTypedDict]]",
+) -> "list[TextPart]":
+    system_instructions: "list[TextPart]" = []
+    for message in messages:
+        if isinstance(message, SystemMessage) and isinstance(message.content, str):
+            system_instructions.append({"type": "text", "content": message.content})
+        elif isinstance(message, SystemMessage) and isinstance(message.content, list):
+            for part in message.content:
+                if not isinstance(part, TextChunk):
+                    continue
+                system_instructions.append({"type": "text", "content": part.text})
+
+        if not isinstance(message, dict):
+            continue
+
+        content = message.get("content")
+        if isinstance(content, str):
+            system_instructions.append({"type": "text", "content": content})
+
+        if not isinstance(content, list):
+            continue
+
+        for part in content:
+            if (
+                not isinstance(part, dict)
+                or part.get("type") != "text"
+                or "text" not in part
+            ):
+                continue
+
+            text = cast("TextChunkTypedDict", part)["text"]
+            system_instructions.append({"type": "text", "content": text})
+
+    return system_instructions
+
+
+def _wrap_complete(f: "Callable[..., Any]") -> "Callable[..., Any]":
+    @wraps(f)
+    def wrap_complete(self: "Chat", *args: "Any", **kwargs: "Any") -> "Any":
+        client = sentry_sdk.get_client()
+        integration = client.get_integration(MistralIntegration)
+        if integration is None or kwargs.get("stream"):
+            return f(self, *args, **kwargs)
+
+        model = kwargs.get("model")
+
+        if has_span_streaming_enabled(client.options):
+            span = sentry_sdk.traces.start_span(
+                name=f"chat {model}" if model is not None else "chat",
+                attributes={
+                    "sentry.op": OP.GEN_AI_CHAT,
+                    "sentry.origin": MistralIntegration.origin,
+                    SPANDATA.GEN_AI_PROVIDER_NAME: "mistral",
+                    SPANDATA.GEN_AI_OPERATION_NAME: "chat",
+                },
+            )
+
+            set_on_span = span.set_attribute
+        else:
+            span = get_start_span_function()(
+                op=OP.GEN_AI_CHAT,
+                name=f"chat {model}" if model is not None else "chat",
+                origin=MistralIntegration.origin,
+            )
+            span.set_data(SPANDATA.GEN_AI_PROVIDER_NAME, "mistral")
+            span.set_data(SPANDATA.GEN_AI_OPERATION_NAME, "chat")
+
+            set_on_span = span.set_data
+
+        with span:
+            if model is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_MODEL, model)
+
+            set_on_span(SPANDATA.GEN_AI_RESPONSE_STREAMING, False)
+
+            messages = kwargs.get("messages")
+            if isinstance(messages, Sequence) and (
+                (
+                    has_data_collection_enabled(client.options)
+                    and client.options["data_collection"]["gen_ai"]["inputs"]
+                )
+                or (
+                    not has_data_collection_enabled(client.options)
+                    and should_send_default_pii()
+                )
+            ):
+                system_instructions = [
+                    message for message in messages if _is_system_instruction(message)
+                ]
+                if len(system_instructions) > 0:
+                    set_on_span(
+                        SPANDATA.GEN_AI_SYSTEM_INSTRUCTIONS,
+                        json.dumps(_transform_system_instructions(system_instructions)),
+                    )
+
+                set_on_span(
+                    SPANDATA.GEN_AI_INPUT_MESSAGES,
+                    json.dumps(_transform_input_messages(messages)),
+                )
+
+            max_tokens = kwargs.get("max_tokens")
+            if max_tokens is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_MAX_TOKENS, max_tokens)
+
+            frequency_penalty = kwargs.get("frequency_penalty")
+            if frequency_penalty is not None:
+                set_on_span(
+                    SPANDATA.GEN_AI_REQUEST_FREQUENCY_PENALTY, frequency_penalty
+                )
+
+            presence_penalty = kwargs.get("presence_penalty")
+            if presence_penalty is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_PRESENCE_PENALTY, presence_penalty)
+
+            temperature = kwargs.get("temperature")
+            if temperature is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_TEMPERATURE, temperature)
+
+            top_p = kwargs.get("top_p")
+            if top_p is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_TOP_P, top_p)
+
+            reasoning_effort = kwargs.get("reasoning_effort")
+            if reasoning_effort is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_REASONING_LEVEL, reasoning_effort)
+
+            response = f(self, *args, **kwargs)
+
+            if not isinstance(response, ChatCompletionResponse):
+                return response
+
+            if response.usage.prompt_tokens is not None:
+                set_on_span(
+                    SPANDATA.GEN_AI_USAGE_INPUT_TOKENS, response.usage.prompt_tokens
+                )
+
+            if response.usage.completion_tokens is not None:
+                set_on_span(
+                    SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS,
+                    response.usage.completion_tokens,
+                )
+
+            if response.usage.total_tokens is not None:
+                set_on_span(
+                    SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS, response.usage.total_tokens
+                )
+
+            if (
+                has_data_collection_enabled(client.options)
+                and client.options["data_collection"]["gen_ai"]["outputs"]
+            ) or (
+                not has_data_collection_enabled(client.options)
+                and should_send_default_pii()
+            ):
+                output_messages: "list[OutputMessage]" = []
+                for choice in response.choices:
+                    if choice.message is None:
+                        continue
+
+                    transformed_message = _transform_output_message(choice.message)
+                    if transformed_message is None:
+                        continue
+
+                    output_messages.append(transformed_message)
+
+                set_on_span(
+                    SPANDATA.GEN_AI_OUTPUT_MESSAGES,
+                    json.dumps(output_messages),
+                )
+
+            return response
+
+    return wrap_complete
+
+
+def _wrap_complete_async(f: "Callable[..., Any]") -> "Callable[..., Any]":
+    @wraps(f)
+    async def wrap_complete_async(self: "Chat", *args: "Any", **kwargs: "Any") -> "Any":
+        client = sentry_sdk.get_client()
+        integration = client.get_integration(MistralIntegration)
+        if integration is None or kwargs.get("stream"):
+            return await f(self, *args, **kwargs)
+
+        model = kwargs.get("model")
+
+        if has_span_streaming_enabled(client.options):
+            span = sentry_sdk.traces.start_span(
+                name=f"chat {model}" if model is not None else "chat",
+                attributes={
+                    "sentry.op": OP.GEN_AI_CHAT,
+                    "sentry.origin": MistralIntegration.origin,
+                    SPANDATA.GEN_AI_PROVIDER_NAME: "mistral",
+                    SPANDATA.GEN_AI_OPERATION_NAME: "chat",
+                },
+            )
+
+            set_on_span = span.set_attribute
+        else:
+            span = get_start_span_function()(
+                op=OP.GEN_AI_CHAT,
+                name=f"chat {model}" if model is not None else "chat",
+                origin=MistralIntegration.origin,
+            )
+            span.set_data(SPANDATA.GEN_AI_PROVIDER_NAME, "mistral")
+            span.set_data(SPANDATA.GEN_AI_OPERATION_NAME, "chat")
+
+            set_on_span = span.set_data
+
+        with span:
+            if model is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_MODEL, model)
+
+            set_on_span(SPANDATA.GEN_AI_RESPONSE_STREAMING, False)
+
+            messages: "Optional[Union[Iterable[ChatCompletionRequestMessage], Iterable[ChatCompletionRequestMessageTypedDict]]]" = kwargs.get(
+                "messages"
+            )
+            if isinstance(messages, Sequence) and (
+                (
+                    has_data_collection_enabled(client.options)
+                    and client.options["data_collection"]["gen_ai"]["inputs"]
+                )
+                or (
+                    not has_data_collection_enabled(client.options)
+                    and should_send_default_pii()
+                )
+            ):
+                system_instructions = [
+                    message for message in messages if _is_system_instruction(message)
+                ]
+                if len(system_instructions) > 0:
+                    set_on_span(
+                        SPANDATA.GEN_AI_SYSTEM_INSTRUCTIONS,
+                        json.dumps(_transform_system_instructions(system_instructions)),
+                    )
+
+                set_on_span(
+                    SPANDATA.GEN_AI_INPUT_MESSAGES,
+                    json.dumps(_transform_input_messages(messages)),
+                )
+
+            max_tokens = kwargs.get("max_tokens")
+            if max_tokens is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_MAX_TOKENS, max_tokens)
+
+            frequency_penalty = kwargs.get("frequency_penalty")
+            if frequency_penalty is not None:
+                set_on_span(
+                    SPANDATA.GEN_AI_REQUEST_FREQUENCY_PENALTY, frequency_penalty
+                )
+
+            presence_penalty = kwargs.get("presence_penalty")
+            if presence_penalty is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_PRESENCE_PENALTY, presence_penalty)
+
+            temperature = kwargs.get("temperature")
+            if temperature is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_TEMPERATURE, temperature)
+
+            top_p = kwargs.get("top_p")
+            if top_p is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_TOP_P, top_p)
+
+            reasoning_effort = kwargs.get("reasoning_effort")
+            if reasoning_effort is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_REASONING_LEVEL, reasoning_effort)
+
+            response = await f(self, *args, **kwargs)
+
+            if not isinstance(response, ChatCompletionResponse):
+                return response
+
+            if response.usage.prompt_tokens is not None:
+                set_on_span(
+                    SPANDATA.GEN_AI_USAGE_INPUT_TOKENS, response.usage.prompt_tokens
+                )
+
+            if response.usage.completion_tokens is not None:
+                set_on_span(
+                    SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS,
+                    response.usage.completion_tokens,
+                )
+
+            if response.usage.total_tokens is not None:
+                set_on_span(
+                    SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS, response.usage.total_tokens
+                )
+
+            if (
+                has_data_collection_enabled(client.options)
+                and client.options["data_collection"]["gen_ai"]["outputs"]
+            ) or (
+                not has_data_collection_enabled(client.options)
+                and should_send_default_pii()
+            ):
+                output_messages: "list[OutputMessage]" = []
+                for choice in response.choices:
+                    if choice.message is None:
+                        continue
+
+                    transformed_message = _transform_output_message(choice.message)
+                    if transformed_message is None:
+                        continue
+
+                    output_messages.append(transformed_message)
+
+                set_on_span(
+                    SPANDATA.GEN_AI_OUTPUT_MESSAGES,
+                    json.dumps(output_messages),
+                )
+
+            return response
+
+    return wrap_complete_async

{sentry_sdk-2.69.2 → sentry_sdk-2.70.0}/sentry_sdk/utils.py

@@ -64,6 +64,7 @@ if TYPE_CHECKING:
 
     from sentry_sdk._types import (
         AttributeValue,
+        DataCollection,
         Event,
         ExcInfo,
         Hint,
@@ -2109,7 +2110,13 @@ def has_data_collection_enabled(options: "Optional[dict[str, Any]]") -> bool:
     if options is None:
         return False
 
-    return "data_collection" in options.get("_experiments", {})
+    data_collection: "Optional[DataCollection]" = options.get("data_collection")
+    # Client options are resolved as part of client initialization, so `data_collection`
+    # being None could be that the user just didn't provide it.
+    # `provided_by_user` is what actually records whether the user actually configured it.
+    return data_collection is not None and data_collection.get(
+        "provided_by_user", False
+    )
 
 
 def get_before_send_log(

{sentry_sdk-2.69.2 → sentry_sdk-2.70.0/sentry_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.69.2
+Version: 2.70.0
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors

{sentry_sdk-2.69.2 → sentry_sdk-2.70.0}/sentry_sdk.egg-info/SOURCES.txt

@@ -101,6 +101,7 @@ sentry_sdk/integrations/litestar.py
 sentry_sdk/integrations/logging.py
 sentry_sdk/integrations/loguru.py
 sentry_sdk/integrations/mcp.py
+sentry_sdk/integrations/mistral.py
 sentry_sdk/integrations/modules.py
 sentry_sdk/integrations/openai.py
 sentry_sdk/integrations/openfeature.py
@@ -422,6 +423,8 @@ tests/integrations/loguru/__init__.py
 tests/integrations/loguru/test_loguru.py
 tests/integrations/mcp/__init__.py
 tests/integrations/mcp/test_mcp.py
+tests/integrations/mistral/__init__.py
+tests/integrations/mistral/test_mistral.py
 tests/integrations/modules/test_modules.py
 tests/integrations/openai/__init__.py
 tests/integrations/openai/test_openai.py

{sentry_sdk-2.69.2 → sentry_sdk-2.70.0}/setup.py

@@ -22,7 +22,7 @@ def get_file_text(file_name):
 
 setup(
     name="sentry-sdk",
-    version="2.69.2",
+    version="2.70.0",
     author="Sentry Team and Contributors",
     author_email="hello@sentry.io",
     url="https://github.com/getsentry/sentry-python",