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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.70.0
+Version: 2.71.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.70.0 → sentry_sdk-2.71.0}/pyproject.toml

@@ -81,6 +81,7 @@ typing = [
     "aiohttp>=3.14.3",
     "openai-agents>=0.22.0",
     "mistralai>=2.10.1",
+    "typesafe-sdk>=0.7.2",
 ]
 test = [
     "dataclasses ; python_full_version < '3.7'",

{sentry_sdk-2.70.0 → sentry_sdk-2.71.0}/sentry_sdk/client.py

@@ -930,14 +930,22 @@ class _Client(BaseClient):
             and event.get("type") != "transaction"
         ):
             new_event = None
+            exception_raised_in_before_send = False
             with capture_internal_exceptions():
-                new_event = before_send(event, hint or {})
+                try:
+                    new_event = before_send(event, hint or {})
+                except Exception:
+                    exception_raised_in_before_send = True
+                    raise
             if new_event is None:
                 logger.info("before send dropped event")
                 if self.transport:
-                    self.transport.record_lost_event(
-                        "before_send", data_category="error"
+                    reason = (
+                        "callback_error"
+                        if exception_raised_in_before_send
+                        else "before_send"
                     )
+                    self.transport.record_lost_event(reason, data_category="error")
 
                 # If this is an exception, reset the DedupeIntegration. It still
                 # remembers the dropped exception as the last exception, meaning
@@ -955,17 +963,29 @@ class _Client(BaseClient):
             and event.get("type") == "transaction"
         ):
             new_event = None
+            exception_raised_in_before_send_transaction = False
             spans_before = len(cast(List[Dict[str, object]], event.get("spans", [])))
+
             with capture_internal_exceptions():
-                new_event = before_send_transaction(event, hint or {})
+                try:
+                    new_event = before_send_transaction(event, hint or {})
+                except Exception:
+                    exception_raised_in_before_send_transaction = True
+                    raise
+
             if new_event is None:
                 logger.info("before send transaction dropped event")
                 if self.transport:
+                    reason = (
+                        "callback_error"
+                        if exception_raised_in_before_send_transaction
+                        else "before_send"
+                    )
                     self.transport.record_lost_event(
-                        reason="before_send", data_category="transaction"
+                        reason=reason, data_category="transaction"
                     )
                     self.transport.record_lost_event(
-                        reason="before_send",
+                        reason=reason,
                         data_category="span",
                         quantity=spans_before + 1,  # +1 for the transaction itself
                     )
@@ -1265,15 +1285,32 @@ class _Client(BaseClient):
                     exception_raised_in_before_send_func = True
                     raise
 
-            if ty in ("log", "metric"):
-                # We are ok with dropping metrics and logs when an exception is raised
-                # because we allow users to drop them in their respect before_send_*
-                # functions.
+            if ty == "log":
                 if exception_raised_in_before_send_func:
+                    if self.transport:
+                        self.transport.record_lost_event(
+                            "callback_error", data_category="log_item"
+                        )
                     return
-                # Logs and metrics can be dropped in their respective
-                # before_send, so if we get None, don't queue them for sending.
                 if serialized is None:
+                    if self.transport:
+                        self.transport.record_lost_event(
+                            "before_send", data_category="log_item"
+                        )
+                    return
+
+            elif ty == "metric":
+                if exception_raised_in_before_send_func:
+                    if self.transport:
+                        self.transport.record_lost_event(
+                            "callback_error", data_category="trace_metric"
+                        )
+                    return
+                if serialized is None:
+                    if self.transport:
+                        self.transport.record_lost_event(
+                            "before_send", data_category="trace_metric"
+                        )
                     return
 
             elif ty == "span" and isinstance(telemetry, StreamedSpan):

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

@@ -1238,6 +1238,7 @@ class OP:
     GEN_AI_CHAT = "gen_ai.chat"
     GEN_AI_CREATE_AGENT = "gen_ai.create_agent"
     GEN_AI_EMBEDDINGS = "gen_ai.embeddings"
+    GEN_AI_EVALUATE = "gen_ai.evaluate"
     GEN_AI_EXECUTE_TOOL = "gen_ai.execute_tool"
     GEN_AI_TEXT_COMPLETION = "gen_ai.text_completion"
     GEN_AI_HANDOFF = "gen_ai.handoff"
@@ -1848,4 +1849,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.70.0"
+VERSION = "2.71.0"

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

@@ -168,6 +168,7 @@ _MIN_VERSIONS = {
     "strawberry": (0, 209, 5),
     "tornado": (6, 0),
     "typer": (0, 15),
+    "typesafe": (0, 7),
     "unleash": (6, 0, 1),
 }
 

{sentry_sdk-2.70.0 → sentry_sdk-2.71.0}/sentry_sdk/integrations/aws_lambda.py

@@ -466,7 +466,7 @@ def _make_request_event_processor(
             else:
                 request["query_string"] = query_string
 
-        if "headers" in aws_event:
+        if "headers" in aws_event and isinstance(aws_event["headers"], dict):
             request["headers"] = _filter_headers(aws_event["headers"])
 
         client_options = sentry_sdk.get_client().options
@@ -508,7 +508,7 @@ def _get_url(aws_event: "Any", aws_context: "Any") -> str:
     path = aws_event.get("path", None)
 
     headers = aws_event.get("headers")
-    if headers is None:
+    if not isinstance(headers, dict):
         headers = {}
 
     host = headers.get("Host", None)

sentry_sdk-2.71.0/sentry_sdk/integrations/typesafe.py

@@ -0,0 +1,417 @@
+import json
+from collections.abc import Mapping
+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_data_collection_enabled,
+    has_span_streaming_enabled,
+)
+
+if TYPE_CHECKING:
+    from typing import (
+        Any,
+        Callable,
+        Literal,
+        Mapping,
+        NotRequired,
+        Sequence,
+        TypedDict,
+        Union,
+    )
+
+    from typesafe_sdk import JSONContent
+    from typesafe_sdk._core.question_types import Questions
+
+    class NoulModel(TypedDict):
+        type: Literal["noul"]
+        instructions: NotRequired[JSONContent | None]
+
+    class ChoiceModel(TypedDict):
+        type: Literal["choice"]
+        criteria: NotRequired[Mapping[str, JSONContent | None]]
+        instructions: NotRequired[JSONContent | None]
+
+    class ScoreModel(TypedDict):
+        type: Literal["score"]
+        criteria: NotRequired[Sequence[JSONContent]]
+        instructions: NotRequired[JSONContent | None]
+
+    class InputMessageModel(TypedDict):
+        type: Literal["evaluation"]
+        state: NotRequired[JSONContent]
+        questions: NotRequired[dict[str, Union[NoulModel, ChoiceModel, ScoreModel]]]
+
+    class NoulEvaluationModel(TypedDict):
+        type: Literal["noul"]
+        noul: float
+
+    class ChoiceEvaluationModel(TypedDict):
+        type: Literal["choice"]
+        choice: str
+        probabilities: dict[str, float]
+        confidence: float
+
+    class ScoreEvaluationModel(TypedDict):
+        type: Literal["score"]
+        score: float
+        probabilities: dict[int, float]
+        confidence: float
+        legend: dict[int, Union[str, dict[str, Any], list[Any]]]
+
+
+try:
+    from typesafe_sdk import Choice, ChoiceAnswer, Noul, NoulAnswer, Score, ScoreAnswer
+    from typesafe_sdk._core.client.aio.client import AsyncTypeSafeClient
+    from typesafe_sdk._core.client.sync.client import TypeSafeClient
+    from typesafe_sdk._core.response_types import Answer, SystemOneResponse
+except ImportError:
+    raise DidNotEnable("typesafe-sdk not installed")
+
+
+class TypeSafeIntegration(Integration):
+    identifier = "typesafe"
+    origin = f"auto.ai.{identifier}"
+
+    @staticmethod
+    def setup_once() -> None:
+        TypeSafeClient.system_one = _wrap_system_one(TypeSafeClient.system_one)  # type: ignore[method-assign]
+        AsyncTypeSafeClient.system_one = _wrap_system_one_async(  # type: ignore[method-assign]
+            AsyncTypeSafeClient.system_one
+        )
+
+
+def _transform_questions(
+    questions: "Questions",
+) -> "dict[str, Union[NoulModel, ChoiceModel, ScoreModel]]":
+    transformed_questions: "dict[str, Union[NoulModel, ChoiceModel, ScoreModel]]" = {}
+    for name, question in questions.items():
+        if isinstance(question, Noul):
+            noul: "NoulModel" = {
+                "type": "noul",
+            }
+
+            if question.instructions is not None:
+                noul["instructions"] = question.instructions
+
+            transformed_questions[name] = noul
+            continue
+
+        if isinstance(question, Choice):
+            choice: "ChoiceModel" = {
+                "type": "choice",
+                "criteria": question.criteria,
+            }
+
+            if question.instructions is not None:
+                choice["instructions"] = question.instructions
+
+            transformed_questions[name] = choice
+            continue
+
+        if isinstance(question, Score):
+            score: "ScoreModel" = {
+                "type": "score",
+                "criteria": question.criteria,
+            }
+
+            if question.instructions is not None:
+                score["instructions"] = question.instructions
+
+            transformed_questions[name] = score
+            continue
+
+        if not isinstance(question, dict):
+            continue
+
+        question_type = question.get("type")
+        if question_type == "noul":
+            noul = {
+                "type": question_type,
+            }
+            if "instructions" in question:
+                noul["instructions"] = question["instructions"]
+
+            transformed_questions[name] = noul
+            continue
+
+        if question_type == "choice":
+            choice = {
+                "type": question_type,
+            }
+            if "criteria" in question:
+                choice["criteria"] = cast(
+                    "Mapping[str, JSONContent | None]", question["criteria"]
+                )
+            if "instructions" in question:
+                choice["instructions"] = question["instructions"]
+
+            transformed_questions[name] = choice
+            continue
+
+        if question_type == "score":
+            score = {
+                "type": question_type,
+            }
+            if "criteria" in question:
+                score["criteria"] = cast("Sequence[JSONContent]", question["criteria"])
+            if "instructions" in question:
+                score["instructions"] = question["instructions"]
+
+            transformed_questions[name] = score
+            continue
+
+    return transformed_questions
+
+
+def _transform_evaluation_answers(
+    answers: "dict[str, Answer]",
+) -> (
+    "dict[str, Union[NoulEvaluationModel, ChoiceEvaluationModel, ScoreEvaluationModel]]"
+):
+    items: "dict[str, Union[NoulEvaluationModel, ChoiceEvaluationModel, ScoreEvaluationModel]]" = {}
+    for name, answer in answers.items():
+        if isinstance(answer, NoulAnswer):
+            items[name] = {
+                "type": "noul",
+                "noul": answer.noul,
+            }
+            continue
+
+        if isinstance(answer, ChoiceAnswer):
+            items[name] = {
+                "type": "choice",
+                "choice": answer.choice,
+                "probabilities": answer.probabilities,
+                "confidence": answer.confidence,
+            }
+            continue
+
+        if isinstance(answer, ScoreAnswer):
+            items[name] = {
+                "type": "score",
+                "score": answer.score,
+                "probabilities": answer.probabilities,
+                "confidence": answer.confidence,
+                "legend": answer.legend,
+            }
+            continue
+
+    return items
+
+
+def _wrap_system_one(f: "Callable[..., Any]") -> "Callable[..., Any]":
+    @wraps(f)
+    def wrap_system_one(self: "TypeSafeClient", *args: "Any", **kwargs: "Any") -> "Any":
+        client = sentry_sdk.get_client()
+        integration = client.get_integration(TypeSafeIntegration)
+        if integration is None:
+            return f(self, *args, **kwargs)
+
+        model = kwargs.get("model")
+        if (
+            model is None
+            and hasattr(self, "_config")
+            and hasattr(self._config, "default_model")
+        ):
+            model = self._config.default_model
+
+        if has_span_streaming_enabled(client.options):
+            span = sentry_sdk.traces.start_span(
+                name=f"evaluate {model}".strip(),
+                attributes={
+                    "sentry.op": OP.GEN_AI_EVALUATE,
+                    "sentry.origin": TypeSafeIntegration.origin,
+                    SPANDATA.GEN_AI_PROVIDER_NAME: "typesafe",
+                    SPANDATA.GEN_AI_OPERATION_NAME: "evaluate",
+                },
+            )
+            set_on_span = span.set_attribute
+        else:
+            span = get_start_span_function()(
+                op=OP.GEN_AI_EVALUATE,
+                name=f"evaluate {model}".strip(),
+                origin=TypeSafeIntegration.origin,
+            )
+            span.set_data(SPANDATA.GEN_AI_PROVIDER_NAME, "typesafe")
+            span.set_data(SPANDATA.GEN_AI_OPERATION_NAME, "evaluate")
+            set_on_span = span.set_data
+
+        with span:
+            if model is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_MODEL, model)
+
+            if (
+                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()
+            ):
+                input_message: "InputMessageModel" = {
+                    "type": "evaluation",
+                }
+
+                state = args[0] if len(args) > 0 else kwargs.get("state")
+                if state is not None:
+                    input_message["state"] = state
+
+                questions = args[1] if len(args) > 1 else kwargs.get("questions")
+                if isinstance(questions, Mapping):
+                    input_message["questions"] = _transform_questions(questions)
+
+                set_on_span(SPANDATA.GEN_AI_INPUT_MESSAGES, json.dumps([input_message]))
+
+            response = f(self, *args, **kwargs)
+
+            if not isinstance(response, SystemOneResponse):
+                return response
+
+            set_on_span(SPANDATA.GEN_AI_RESPONSE_MODEL, response.model)
+
+            if response.usage.input_tokens is not None:
+                set_on_span(
+                    SPANDATA.GEN_AI_USAGE_INPUT_TOKENS, response.usage.input_tokens
+                )
+
+            if response.usage.output_tokens is not None:
+                set_on_span(
+                    SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS, response.usage.output_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()
+            ):
+                set_on_span(
+                    SPANDATA.GEN_AI_OUTPUT_MESSAGES,
+                    json.dumps(
+                        [
+                            {
+                                "type": "evaluation",
+                                "answers": _transform_evaluation_answers(
+                                    response.answers
+                                ),
+                            }
+                        ]
+                    ),
+                )
+
+            return response
+
+    return wrap_system_one
+
+
+def _wrap_system_one_async(f: "Callable[..., Any]") -> "Callable[..., Any]":
+    @wraps(f)
+    async def wrap_system_one_async(
+        self: "AsyncTypeSafeClient", *args: "Any", **kwargs: "Any"
+    ) -> "Any":
+        client = sentry_sdk.get_client()
+        integration = client.get_integration(TypeSafeIntegration)
+        if integration is None:
+            return await f(self, *args, **kwargs)
+
+        model = kwargs.get("model")
+        if (
+            model is None
+            and hasattr(self, "_config")
+            and hasattr(self._config, "default_model")
+        ):
+            model = self._config.default_model
+
+        if has_span_streaming_enabled(client.options):
+            span = sentry_sdk.traces.start_span(
+                name=f"evaluate {model}".strip(),
+                attributes={
+                    "sentry.op": OP.GEN_AI_EVALUATE,
+                    "sentry.origin": TypeSafeIntegration.origin,
+                    SPANDATA.GEN_AI_PROVIDER_NAME: "typesafe",
+                    SPANDATA.GEN_AI_OPERATION_NAME: "evaluate",
+                },
+            )
+            set_on_span = span.set_attribute
+        else:
+            span = get_start_span_function()(
+                op=OP.GEN_AI_EVALUATE,
+                name=f"evaluate {model}".strip(),
+                origin=TypeSafeIntegration.origin,
+            )
+            span.set_data(SPANDATA.GEN_AI_PROVIDER_NAME, "typesafe")
+            span.set_data(SPANDATA.GEN_AI_OPERATION_NAME, "evaluate")
+            set_on_span = span.set_data
+
+        with span:
+            if model is not None:
+                set_on_span(SPANDATA.GEN_AI_REQUEST_MODEL, model)
+
+            if (
+                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()
+            ):
+                input_message: "InputMessageModel" = {
+                    "type": "evaluation",
+                }
+
+                state = args[0] if len(args) > 0 else kwargs.get("state")
+                if state is not None:
+                    input_message["state"] = state
+
+                questions = args[1] if len(args) > 1 else kwargs.get("questions")
+                if isinstance(questions, Mapping):
+                    input_message["questions"] = _transform_questions(questions)
+
+                set_on_span(SPANDATA.GEN_AI_INPUT_MESSAGES, json.dumps([input_message]))
+
+            response = await f(self, *args, **kwargs)
+
+            if not isinstance(response, SystemOneResponse):
+                return response
+
+            set_on_span(SPANDATA.GEN_AI_RESPONSE_MODEL, response.model)
+
+            if response.usage.input_tokens is not None:
+                set_on_span(
+                    SPANDATA.GEN_AI_USAGE_INPUT_TOKENS, response.usage.input_tokens
+                )
+
+            if response.usage.output_tokens is not None:
+                set_on_span(
+                    SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS, response.usage.output_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()
+            ):
+                set_on_span(
+                    SPANDATA.GEN_AI_OUTPUT_MESSAGES,
+                    json.dumps(
+                        [
+                            {
+                                "type": "evaluation",
+                                "answers": _transform_evaluation_answers(
+                                    response.answers
+                                ),
+                            }
+                        ]
+                    ),
+                )
+
+            return response
+
+    return wrap_system_one_async

{sentry_sdk-2.70.0 → sentry_sdk-2.71.0}/sentry_sdk/profiler/transaction_profiler.py

@@ -286,7 +286,15 @@ class Profile:
         options = client.options
 
         if callable(options.get("profiles_sampler")):
-            sample_rate = options["profiles_sampler"](sampling_context)
+            try:
+                sample_rate = options["profiles_sampler"](sampling_context)
+            except Exception:
+                logger.warning(
+                    "[Profiling] profiles_sampler raised; unsampling profile",
+                    exc_info=True,
+                )
+                self.sampled = False
+                return
         elif options["profiles_sample_rate"] is not None:
             sample_rate = options["profiles_sample_rate"]
         else:

{sentry_sdk-2.70.0 → sentry_sdk-2.71.0}/sentry_sdk/scope.py

@@ -1828,7 +1828,9 @@ class Scope:
             )
 
             for error_processor in error_processors:
-                new_event = error_processor(event, exc_info)
+                new_event = event
+                with capture_internal_exceptions():
+                    new_event = error_processor(event, exc_info)
                 if new_event is None:
                     return self._drop(error_processor, "error processor")
 

{sentry_sdk-2.70.0 → sentry_sdk-2.71.0}/sentry_sdk/tracing.py

@@ -1217,14 +1217,11 @@ class Transaction(Span):
                 sample_rate = client.options["traces_sampler"](sampling_context)
             except Exception:
                 logger.warning(
-                    "[Tracing] traces_sampler raised; falling back to parent sample rate or traces_sample_rate",
+                    "[Tracing] traces_sampler raised; unsampling trace",
                     exc_info=True,
                 )
-                sample_rate = (
-                    sampling_context["parent_sampled"]
-                    if sampling_context["parent_sampled"] is not None
-                    else client.options["traces_sample_rate"]
-                )
+                self.sampled = False
+                return
         else:
             sample_rate = (
                 sampling_context["parent_sampled"]

{sentry_sdk-2.70.0 → sentry_sdk-2.71.0}/sentry_sdk/tracing_utils.py

@@ -1702,13 +1702,10 @@ def _make_sampling_decision(
             sample_rate = client.options["traces_sampler"](sampling_context)
         except Exception:
             logger.warning(
-                "[Tracing] traces_sampler raised; falling back to parent sample rate or traces_sample_rate",
+                "[Tracing] traces_sampler raised; unsampling trace",
                 exc_info=True,
             )
-            if propagation_context.parent_sampled is not None:
-                sample_rate = propagation_context.parent_sampled
-            else:
-                sample_rate = client.options["traces_sample_rate"]
+            return False, None, None, "callback_error"
     else:
         if propagation_context.parent_sampled is not None:
             sample_rate = propagation_context.parent_sampled

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.70.0
+Version: 2.71.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.70.0 → sentry_sdk-2.71.0}/sentry_sdk.egg-info/SOURCES.txt

@@ -128,6 +128,7 @@ sentry_sdk/integrations/threading.py
 sentry_sdk/integrations/tornado.py
 sentry_sdk/integrations/trytond.py
 sentry_sdk/integrations/typer.py
+sentry_sdk/integrations/typesafe.py
 sentry_sdk/integrations/unleash.py
 sentry_sdk/integrations/unraisablehook.py
 sentry_sdk/integrations/wsgi.py
@@ -298,7 +299,9 @@ tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStre
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreaming/index.py
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingDataCollection/.gitignore
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingDataCollection/index.py
+tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingDataCollectionUserInfoOff/.gitignore
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingDataCollectionUserInfoOff/index.py
+tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingDataCollectionUserInfoOn/.gitignore
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingDataCollectionUserInfoOn/index.py
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingPii/.gitignore
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingPii/index.py
@@ -507,6 +510,8 @@ tests/integrations/trytond/__init__.py
 tests/integrations/trytond/test_trytond.py
 tests/integrations/typer/__init__.py
 tests/integrations/typer/test_typer.py
+tests/integrations/typesafe/__init__.py
+tests/integrations/typesafe/test_typesafe.py
 tests/integrations/unleash/__init__.py
 tests/integrations/unleash/test_unleash.py
 tests/integrations/unleash/testutils.py