sentry-sdk 3.0.0a1__py2.py3-none-any.whl → 3.0.0a3__py2.py3-none-any.whl

sentry_sdk/crons/api.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import uuid
 
 import sentry_sdk
@@ -10,17 +11,16 @@ if TYPE_CHECKING:
 
 
 def _create_check_in_event(
-    monitor_slug=None,  # type: Optional[str]
-    check_in_id=None,  # type: Optional[str]
-    status=None,  # type: Optional[str]
-    duration_s=None,  # type: Optional[float]
-    monitor_config=None,  # type: Optional[MonitorConfig]
-):
-    # type: (...) -> Event
+    monitor_slug: Optional[str] = None,
+    check_in_id: Optional[str] = None,
+    status: Optional[str] = None,
+    duration_s: Optional[float] = None,
+    monitor_config: Optional[MonitorConfig] = None,
+) -> Event:
     options = sentry_sdk.get_client().options
-    check_in_id = check_in_id or uuid.uuid4().hex  # type: str
+    check_in_id = check_in_id or uuid.uuid4().hex
 
-    check_in = {
+    check_in: Event = {
         "type": "check_in",
         "monitor_slug": monitor_slug,
         "check_in_id": check_in_id,
@@ -28,7 +28,7 @@ def _create_check_in_event(
         "duration": duration_s,
         "environment": options.get("environment", None),
         "release": options.get("release", None),
-    }  # type: Event
+    }
 
     if monitor_config:
         check_in["monitor_config"] = monitor_config
@@ -37,13 +37,12 @@ def _create_check_in_event(
 
 
 def capture_checkin(
-    monitor_slug=None,  # type: Optional[str]
-    check_in_id=None,  # type: Optional[str]
-    status=None,  # type: Optional[str]
-    duration=None,  # type: Optional[float]
-    monitor_config=None,  # type: Optional[MonitorConfig]
-):
-    # type: (...) -> str
+    monitor_slug: Optional[str] = None,
+    check_in_id: Optional[str] = None,
+    status: Optional[str] = None,
+    duration: Optional[float] = None,
+    monitor_config: Optional[MonitorConfig] = None,
+) -> str:
     check_in_event = _create_check_in_event(
         monitor_slug=monitor_slug,
         check_in_id=check_in_id,

sentry_sdk/crons/decorator.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from functools import wraps
 from inspect import iscoroutinefunction
 
@@ -16,8 +17,6 @@ if TYPE_CHECKING:
         ParamSpec,
         Type,
         TypeVar,
-        Union,
-        cast,
         overload,
     )
     from sentry_sdk._types import MonitorConfig
@@ -55,13 +54,15 @@ class monitor:  # noqa: N801
     ```
     """
 
-    def __init__(self, monitor_slug=None, monitor_config=None):
-        # type: (Optional[str], Optional[MonitorConfig]) -> None
+    def __init__(
+        self,
+        monitor_slug: Optional[str] = None,
+        monitor_config: Optional[MonitorConfig] = None,
+    ) -> None:
         self.monitor_slug = monitor_slug
         self.monitor_config = monitor_config
 
-    def __enter__(self):
-        # type: () -> None
+    def __enter__(self) -> None:
         self.start_timestamp = now()
         self.check_in_id = capture_checkin(
             monitor_slug=self.monitor_slug,
@@ -69,8 +70,12 @@ class monitor:  # noqa: N801
             monitor_config=self.monitor_config,
         )
 
-    def __exit__(self, exc_type, exc_value, traceback):
-        # type: (Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]) -> None
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
         duration_s = now() - self.start_timestamp
 
         if exc_type is None and exc_value is None and traceback is None:
@@ -89,46 +94,39 @@ class monitor:  # noqa: N801
     if TYPE_CHECKING:
 
         @overload
-        def __call__(self, fn):
-            # type: (Callable[P, Awaitable[Any]]) -> Callable[P, Awaitable[Any]]
+        def __call__(
+            self, fn: Callable[P, Awaitable[Any]]
+        ) -> Callable[P, Awaitable[Any]]:
             # Unfortunately, mypy does not give us any reliable way to type check the
             # return value of an Awaitable (i.e. async function) for this overload,
             # since calling iscouroutinefunction narrows the type to Callable[P, Awaitable[Any]].
             ...
 
         @overload
-        def __call__(self, fn):
-            # type: (Callable[P, R]) -> Callable[P, R]
-            ...
+        def __call__(self, fn: Callable[P, R]) -> Callable[P, R]: ...
 
     def __call__(
         self,
-        fn,  # type: Union[Callable[P, R], Callable[P, Awaitable[Any]]]
-    ):
-        # type: (...) -> Union[Callable[P, R], Callable[P, Awaitable[Any]]]
+        fn: Callable[..., Any],
+    ) -> Callable[..., Any]:
         if iscoroutinefunction(fn):
             return self._async_wrapper(fn)
-
         else:
-            if TYPE_CHECKING:
-                fn = cast("Callable[P, R]", fn)
             return self._sync_wrapper(fn)
 
-    def _async_wrapper(self, fn):
-        # type: (Callable[P, Awaitable[Any]]) -> Callable[P, Awaitable[Any]]
+    def _async_wrapper(
+        self, fn: Callable[P, Awaitable[Any]]
+    ) -> Callable[P, Awaitable[Any]]:
         @wraps(fn)
-        async def inner(*args: "P.args", **kwargs: "P.kwargs"):
-            # type: (...) -> R
+        async def inner(*args: P.args, **kwargs: P.kwargs) -> R:
             with self:
                 return await fn(*args, **kwargs)
 
         return inner
 
-    def _sync_wrapper(self, fn):
-        # type: (Callable[P, R]) -> Callable[P, R]
+    def _sync_wrapper(self, fn: Callable[P, R]) -> Callable[P, R]:
         @wraps(fn)
-        def inner(*args: "P.args", **kwargs: "P.kwargs"):
-            # type: (...) -> R
+        def inner(*args: P.args, **kwargs: P.kwargs) -> R:
             with self:
                 return fn(*args, **kwargs)
 

sentry_sdk/debug.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 import logging
 
@@ -8,22 +9,19 @@ from logging import LogRecord
 
 
 class _DebugFilter(logging.Filter):
-    def filter(self, record):
-        # type: (LogRecord) -> bool
+    def filter(self, record: LogRecord) -> bool:
         if _client_init_debug.get(False):
             return True
 
         return get_client().options["debug"]
 
 
-def init_debug_support():
-    # type: () -> None
+def init_debug_support() -> None:
     if not logger.handlers:
         configure_logger()
 
 
-def configure_logger():
-    # type: () -> None
+def configure_logger() -> None:
     _handler = logging.StreamHandler(sys.stderr)
     _handler.setFormatter(logging.Formatter(" [sentry] %(levelname)s: %(message)s"))
     logger.addHandler(_handler)

sentry_sdk/envelope.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import io
 import json
 import mimetypes
@@ -8,18 +9,11 @@ from sentry_sdk.utils import json_dumps, capture_internal_exceptions
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any
-    from typing import Optional
-    from typing import Union
-    from typing import Dict
-    from typing import List
-    from typing import Iterator
-
     from sentry_sdk._types import Event, EventDataCategory
+    from typing import Any, Optional, Union, Dict, List, Iterator
 
 
-def parse_json(data):
-    # type: (Union[bytes, str]) -> Any
+def parse_json(data: Union[bytes, str]) -> Any:
     # on some python 3 versions this needs to be bytes
     if isinstance(data, bytes):
         data = data.decode("utf-8", "replace")
@@ -35,10 +29,9 @@ class Envelope:
 
     def __init__(
         self,
-        headers=None,  # type: Optional[Dict[str, Any]]
-        items=None,  # type: Optional[List[Item]]
-    ):
-        # type: (...) -> None
+        headers: Optional[Dict[str, Any]] = None,
+        items: Optional[List[Item]] = None,
+    ) -> None:
         if headers is not None:
             headers = dict(headers)
         self.headers = headers or {}
@@ -49,35 +42,22 @@ class Envelope:
         self.items = items
 
     @property
-    def description(self):
-        # type: (...) -> str
+    def description(self) -> str:
         return "envelope with %s items (%s)" % (
             len(self.items),
             ", ".join(x.data_category for x in self.items),
         )
 
-    def add_event(
-        self, event  # type: Event
-    ):
-        # type: (...) -> None
+    def add_event(self, event: Event) -> None:
         self.add_item(Item(payload=PayloadRef(json=event), type="event"))
 
-    def add_transaction(
-        self, transaction  # type: Event
-    ):
-        # type: (...) -> None
+    def add_transaction(self, transaction: Event) -> None:
         self.add_item(Item(payload=PayloadRef(json=transaction), type="transaction"))
 
-    def add_profile(
-        self, profile  # type: Any
-    ):
-        # type: (...) -> None
+    def add_profile(self, profile: Any) -> None:
         self.add_item(Item(payload=PayloadRef(json=profile), type="profile"))
 
-    def add_profile_chunk(
-        self, profile_chunk  # type: Any
-    ):
-        # type: (...) -> None
+    def add_profile_chunk(self, profile_chunk: Any) -> None:
         self.add_item(
             Item(
                 payload=PayloadRef(json=profile_chunk),
@@ -86,72 +66,50 @@ class Envelope:
             )
         )
 
-    def add_checkin(
-        self, checkin  # type: Any
-    ):
-        # type: (...) -> None
+    def add_checkin(self, checkin: Any) -> None:
         self.add_item(Item(payload=PayloadRef(json=checkin), type="check_in"))
 
-    def add_session(
-        self, session  # type: Union[Session, Any]
-    ):
-        # type: (...) -> None
+    def add_session(self, session: Union[Session, Any]) -> None:
         if isinstance(session, Session):
             session = session.to_json()
         self.add_item(Item(payload=PayloadRef(json=session), type="session"))
 
-    def add_sessions(
-        self, sessions  # type: Any
-    ):
-        # type: (...) -> None
+    def add_sessions(self, sessions: Any) -> None:
         self.add_item(Item(payload=PayloadRef(json=sessions), type="sessions"))
 
-    def add_item(
-        self, item  # type: Item
-    ):
-        # type: (...) -> None
+    def add_item(self, item: Item) -> None:
         self.items.append(item)
 
-    def get_event(self):
-        # type: (...) -> Optional[Event]
+    def get_event(self) -> Optional[Event]:
         for items in self.items:
             event = items.get_event()
             if event is not None:
                 return event
         return None
 
-    def get_transaction_event(self):
-        # type: (...) -> Optional[Event]
+    def get_transaction_event(self) -> Optional[Event]:
         for item in self.items:
             event = item.get_transaction_event()
             if event is not None:
                 return event
         return None
 
-    def __iter__(self):
-        # type: (...) -> Iterator[Item]
+    def __iter__(self) -> Iterator[Item]:
         return iter(self.items)
 
-    def serialize_into(
-        self, f  # type: Any
-    ):
-        # type: (...) -> None
+    def serialize_into(self, f: Any) -> None:
         f.write(json_dumps(self.headers))
         f.write(b"\n")
         for item in self.items:
             item.serialize_into(f)
 
-    def serialize(self):
-        # type: (...) -> bytes
+    def serialize(self) -> bytes:
         out = io.BytesIO()
         self.serialize_into(out)
         return out.getvalue()
 
     @classmethod
-    def deserialize_from(
-        cls, f  # type: Any
-    ):
-        # type: (...) -> Envelope
+    def deserialize_from(cls, f: Any) -> Envelope:
         headers = parse_json(f.readline())
         items = []
         while 1:
@@ -162,31 +120,25 @@ class Envelope:
         return cls(headers=headers, items=items)
 
     @classmethod
-    def deserialize(
-        cls, bytes  # type: bytes
-    ):
-        # type: (...) -> Envelope
+    def deserialize(cls, bytes: bytes) -> Envelope:
         return cls.deserialize_from(io.BytesIO(bytes))
 
-    def __repr__(self):
-        # type: (...) -> str
+    def __repr__(self) -> str:
         return "<Envelope headers=%r items=%r>" % (self.headers, self.items)
 
 
 class PayloadRef:
     def __init__(
         self,
-        bytes=None,  # type: Optional[bytes]
-        path=None,  # type: Optional[Union[bytes, str]]
-        json=None,  # type: Optional[Any]
-    ):
-        # type: (...) -> None
+        bytes: Optional[bytes] = None,
+        path: Optional[Union[bytes, str]] = None,
+        json: Optional[Any] = None,
+    ) -> None:
         self.json = json
         self.bytes = bytes
         self.path = path
 
-    def get_bytes(self):
-        # type: (...) -> bytes
+    def get_bytes(self) -> bytes:
         if self.bytes is None:
             if self.path is not None:
                 with capture_internal_exceptions():
@@ -197,8 +149,7 @@ class PayloadRef:
         return self.bytes or b""
 
     @property
-    def inferred_content_type(self):
-        # type: (...) -> str
+    def inferred_content_type(self) -> str:
         if self.json is not None:
             return "application/json"
         elif self.path is not None:
@@ -210,20 +161,19 @@ class PayloadRef:
                 return ty
         return "application/octet-stream"
 
-    def __repr__(self):
-        # type: (...) -> str
+    def __repr__(self) -> str:
         return "<Payload %r>" % (self.inferred_content_type,)
 
 
 class Item:
     def __init__(
         self,
-        payload,  # type: Union[bytes, str, PayloadRef]
-        headers=None,  # type: Optional[Dict[str, Any]]
-        type=None,  # type: Optional[str]
-        content_type=None,  # type: Optional[str]
-        filename=None,  # type: Optional[str]
-    ):
+        payload: Union[bytes, str, PayloadRef],
+        headers: Optional[Dict[str, Any]] = None,
+        type: Optional[str] = None,
+        content_type: Optional[str] = None,
+        filename: Optional[str] = None,
+    ) -> None:
         if headers is not None:
             headers = dict(headers)
         elif headers is None:
@@ -247,8 +197,7 @@ class Item:
 
         self.payload = payload
 
-    def __repr__(self):
-        # type: (...) -> str
+    def __repr__(self) -> str:
         return "<Item headers=%r payload=%r data_category=%r>" % (
             self.headers,
             self.payload,
@@ -256,13 +205,11 @@ class Item:
         )
 
     @property
-    def type(self):
-        # type: (...) -> Optional[str]
+    def type(self) -> Optional[str]:
         return self.headers.get("type")
 
     @property
-    def data_category(self):
-        # type: (...) -> EventDataCategory
+    def data_category(self) -> EventDataCategory:
         ty = self.headers.get("type")
         if ty == "session" or ty == "sessions":
             return "session"
@@ -285,12 +232,10 @@ class Item:
         else:
             return "default"
 
-    def get_bytes(self):
-        # type: (...) -> bytes
+    def get_bytes(self) -> bytes:
         return self.payload.get_bytes()
 
-    def get_event(self):
-        # type: (...) -> Optional[Event]
+    def get_event(self) -> Optional[Event]:
         """
         Returns an error event if there is one.
         """
@@ -298,16 +243,12 @@ class Item:
             return self.payload.json
         return None
 
-    def get_transaction_event(self):
-        # type: (...) -> Optional[Event]
+    def get_transaction_event(self) -> Optional[Event]:
         if self.type == "transaction" and self.payload.json is not None:
             return self.payload.json
         return None
 
-    def serialize_into(
-        self, f  # type: Any
-    ):
-        # type: (...) -> None
+    def serialize_into(self, f: Any) -> None:
         headers = dict(self.headers)
         bytes = self.get_bytes()
         headers["length"] = len(bytes)
@@ -316,17 +257,13 @@ class Item:
         f.write(bytes)
         f.write(b"\n")
 
-    def serialize(self):
-        # type: (...) -> bytes
+    def serialize(self) -> bytes:
         out = io.BytesIO()
         self.serialize_into(out)
         return out.getvalue()
 
     @classmethod
-    def deserialize_from(
-        cls, f  # type: Any
-    ):
-        # type: (...) -> Optional[Item]
+    def deserialize_from(cls, f: Any) -> Optional[Item]:
         line = f.readline().rstrip()
         if not line:
             return None
@@ -346,8 +283,5 @@ class Item:
         return rv
 
     @classmethod
-    def deserialize(
-        cls, bytes  # type: bytes
-    ):
-        # type: (...) -> Optional[Item]
+    def deserialize(cls, bytes: bytes) -> Optional[Item]:
         return cls.deserialize_from(io.BytesIO(bytes))

sentry_sdk/feature_flags.py

@@ -1,23 +1,22 @@
+from __future__ import annotations
 import copy
 import sentry_sdk
 from sentry_sdk._lru_cache import LRUCache
 from threading import Lock
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import TypedDict
+    from typing import Any, TypedDict
 
     FlagData = TypedDict("FlagData", {"flag": str, "result": bool})
 
-
 DEFAULT_FLAG_CAPACITY = 100
 
 
 class FlagBuffer:
 
-    def __init__(self, capacity):
-        # type: (int) -> None
+    def __init__(self, capacity: int) -> None:
         self.capacity = capacity
         self.lock = Lock()
 
@@ -25,26 +24,22 @@ class FlagBuffer:
         # directly you're on your own!
         self.__buffer = LRUCache(capacity)
 
-    def clear(self):
-        # type: () -> None
+    def clear(self) -> None:
         self.__buffer = LRUCache(self.capacity)
 
-    def __deepcopy__(self, memo):
-        # type: (dict[int, Any]) -> FlagBuffer
+    def __deepcopy__(self, memo: dict[int, Any]) -> FlagBuffer:
         with self.lock:
             buffer = FlagBuffer(self.capacity)
             buffer.__buffer = copy.deepcopy(self.__buffer, memo)
             return buffer
 
-    def get(self):
-        # type: () -> list[FlagData]
+    def get(self) -> list[FlagData]:
         with self.lock:
             return [
                 {"flag": key, "result": value} for key, value in self.__buffer.get_all()
             ]
 
-    def set(self, flag, result):
-        # type: (str, bool) -> None
+    def set(self, flag: str, result: bool) -> None:
         if isinstance(result, FlagBuffer):
             # If someone were to insert `self` into `self` this would create a circular dependency
             # on the lock. This is of course a deadlock. However, this is far outside the expected
@@ -58,8 +53,7 @@ class FlagBuffer:
             self.__buffer.set(flag, result)
 
 
-def add_feature_flag(flag, result):
-    # type: (str, bool) -> None
+def add_feature_flag(flag: str, result: bool) -> None:
     """
     Records a flag and its value to be sent on subsequent error events.
     We recommend you do this on flag evaluations. Flags are buffered per Sentry scope.

sentry_sdk/integrations/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from abc import ABC, abstractmethod
 from threading import Lock
 
@@ -23,20 +24,20 @@ _DEFAULT_FAILED_REQUEST_STATUS_CODES = frozenset(range(500, 600))
 _installer_lock = Lock()
 
 # Set of all integration identifiers we have attempted to install
-_processed_integrations = set()  # type: Set[str]
+_processed_integrations: Set[str] = set()
 
 # Set of all integration identifiers we have actually installed
-_installed_integrations = set()  # type: Set[str]
+_installed_integrations: Set[str] = set()
 
 
 def _generate_default_integrations_iterator(
-    integrations,  # type: List[str]
-    auto_enabling_integrations,  # type: List[str]
-):
-    # type: (...) -> Callable[[bool], Iterator[Type[Integration]]]
+    integrations: List[str],
+    auto_enabling_integrations: List[str],
+) -> Callable[[bool], Iterator[Type[Integration]]]:
 
-    def iter_default_integrations(with_auto_enabling_integrations):
-        # type: (bool) -> Iterator[Type[Integration]]
+    def iter_default_integrations(
+        with_auto_enabling_integrations: bool,
+    ) -> Iterator[Type[Integration]]:
         """Returns an iterator of the default integration classes:"""
         from importlib import import_module
 
@@ -146,6 +147,7 @@ _MIN_VERSIONS = {
     "launchdarkly": (9, 8, 0),
     "loguru": (0, 7, 0),
     "openai": (1, 0, 0),
+    "openai_agents": (0, 0, 19),
     "openfeature": (0, 7, 1),
     "quart": (0, 16, 0),
     "ray": (2, 7, 0),
@@ -165,12 +167,13 @@ _MIN_VERSIONS = {
 
 
 def setup_integrations(
-    integrations,
-    with_defaults=True,
-    with_auto_enabling_integrations=False,
-    disabled_integrations=None,
-):
-    # type: (Sequence[Integration], bool, bool, Optional[Sequence[Union[type[Integration], Integration]]]) -> Dict[str, Integration]
+    integrations: Sequence[Integration],
+    with_defaults: bool = True,
+    with_auto_enabling_integrations: bool = False,
+    disabled_integrations: Optional[
+        Sequence[Union[type[Integration], Integration]]
+    ] = None,
+) -> Dict[str, Integration]:
     """
     Given a list of integration instances, this installs them all.
 
@@ -239,8 +242,11 @@ def setup_integrations(
     return integrations
 
 
-def _check_minimum_version(integration, version, package=None):
-    # type: (type[Integration], Optional[tuple[int, ...]], Optional[str]) -> None
+def _check_minimum_version(
+    integration: type[Integration],
+    version: Optional[tuple[int, ...]],
+    package: Optional[str] = None,
+) -> None:
     package = package or integration.identifier
 
     if version is None:
@@ -276,13 +282,12 @@ class Integration(ABC):
     install = None
     """Legacy method, do not implement."""
 
-    identifier = None  # type: str
+    identifier: str
     """String unique ID of integration type"""
 
     @staticmethod
     @abstractmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         """
         Initialize the integration.