ref: Add more type annotations

Author: untitaker

mypy.ini

@@ -10,7 +10,7 @@ disallow_incomplete_defs = True
 ; disallow_subclassing_any = True
 ; disallow_untyped_calls = True
 disallow_untyped_decorators = True
-; disallow_untyped_defs = True
+disallow_untyped_defs = True
 no_implicit_optional = True
 strict_equality = True
 strict_optional = True
@@ -19,11 +19,25 @@ warn_redundant_casts = True
 ; warn_unused_configs = True
 ; warn_unused_ignores = True
 
+
+; Relaxations:
+
+[mypy-sentry_sdk.tracing]
+disallow_untyped_defs = False
+
+[mypy-sentry_sdk._compat]
+disallow_untyped_defs = False
+
+[mypy-sentry_sdk.scope]
+disallow_untyped_defs = False
+
 [mypy-sentry_sdk.integrations.*]
 disallow_any_generics = False
+disallow_untyped_defs = False
 
 [mypy-sentry_sdk.utils]
 disallow_any_generics = False
+disallow_untyped_defs = False
 
 [mypy-django.*]
 ignore_missing_imports = True

sentry_sdk/api.py

@@ -15,10 +15,12 @@
 
     from sentry_sdk.utils import Event, Hint, Breadcrumb, BreadcrumbHint
 
+    T = TypeVar("T")
     F = TypeVar("F", bound=Callable[..., Any])
 else:
 
     def overload(x):
+        # type: (T) -> T
         return x
 
 
@@ -91,7 +93,10 @@ def configure_scope(callback):
 
 
 @hubmethod  # noqa
-def configure_scope(callback=None):
+def configure_scope(
+    callback=None  # type: Optional[Callable[[Scope], None]]
+):
+    # type: (...) -> Optional[ContextManager[Scope]]
     hub = Hub.current
     if hub is not None:
         return hub.configure_scope(callback)
@@ -120,7 +125,10 @@ def push_scope(callback):
 
 
 @hubmethod  # noqa
-def push_scope(callback=None):
+def push_scope(
+    callback=None  # type: Optional[Callable[[Scope], None]]
+):
+    # type: (...) -> Optional[ContextManager[Scope]]
     hub = Hub.current
     if hub is not None:
         return hub.push_scope(callback)
@@ -138,6 +146,7 @@ def inner():
 
 @hubmethod
 def flush(timeout=None, callback=None):
+    # type: (Optional[float], Optional[Callable[[int, float], None]]) -> None
     hub = Hub.current
     if hub is not None:
         return hub.flush(timeout=timeout, callback=callback)

sentry_sdk/client.py

@@ -92,6 +92,7 @@ def __init__(self, *args, **kwargs):
 
     @property
     def dsn(self):
+        # type: () -> Optional[str]
         """Returns the configured DSN as string."""
         return self.options["dsn"]
 
@@ -259,7 +260,9 @@ def flush(self, timeout=None, callback=None):
             self.transport.flush(timeout=timeout, callback=callback)
 
     def __enter__(self):
+        # type: () -> Client
         return self
 
     def __exit__(self, exc_type, exc_value, tb):
+        # type: (Any, Any, Any) -> None
         self.close()

sentry_sdk/debug.py

@@ -38,6 +38,7 @@ def configure_logger():
 def configure_debug_hub():
     # type: () -> None
     def _get_debug_hub():
+        # type: () -> Hub
         return Hub.current
 
     utils._get_debug_hub = _get_debug_hub

sentry_sdk/hub.py

@@ -28,13 +28,17 @@
     from typing import Callable
     from typing import Generator
     from typing import Type
+    from typing import TypeVar
     from typing import overload
 
     from sentry_sdk.integrations import Integration
     from sentry_sdk.utils import Event, Hint, Breadcrumb, BreadcrumbHint
+
+    T = TypeVar("T")
 else:
 
     def overload(x):
+        # type: (T) -> T
         return x
 
 
@@ -60,12 +64,15 @@ def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_value, tb):
+        # type: (Any, Any, Any) -> None
         c = self._client
         if c is not None:
             c.close()
 
 
 def init(*args, **kwargs):
+    # type: (*str, **Any) -> ContextManager[Any]
+    # TODO: https://github.com/getsentry/sentry-python/issues/272
     """Initializes the SDK and optionally integrations.
 
     This takes the same arguments as the client constructor.
@@ -92,16 +99,19 @@ def current(self):
 
     @property
     def main(self):
+        # type: () -> Hub
         """Returns the main instance of the hub."""
         return GLOBAL_HUB
 
 
 class _HubManager(object):
     def __init__(self, hub):
+        # type: (Hub) -> None
         self._old = Hub.current
         _local.set(hub)
 
     def __exit__(self, exc_type, exc_value, tb):
+        # type: (Any, Any, Any) -> None
         _local.set(self._old)
 
 
@@ -119,6 +129,7 @@ def __enter__(self):
         return scope
 
     def __exit__(self, exc_type, exc_value, tb):
+        # type: (Any, Any, Any) -> None
         current_len = len(self._hub._stack)
         if current_len < self._original_len:
             logger.error(
@@ -200,6 +211,7 @@ def __exit__(
         _local.set(old)
 
     def run(self, callback):
+        # type: (Callable[[], T]) -> T
         """Runs a callback in the context of the hub.  Alternatively the
         with statement can be used on the hub directly.
         """
@@ -260,6 +272,7 @@ def last_event_id(self):
         return self._last_event_id
 
     def bind_client(self, new):
+        # type: (Optional[Client]) -> None
         """Binds a new client to the hub."""
         top = self._stack[-1]
         self._stack[-1] = (new, top[1])
@@ -361,16 +374,19 @@ def add_breadcrumb(self, crumb=None, hint=None, **kwargs):
             scope._breadcrumbs.popleft()
 
     @overload  # noqa
-    def push_scope(self):
-        # type: () -> ContextManager[Scope]
+    def push_scope(self, callback=None):
+        # type: (Optional[None]) -> ContextManager[Scope]
         pass
 
     @overload  # noqa
     def push_scope(self, callback):
         # type: (Callable[[Scope], None]) -> None
         pass
 
-    def push_scope(self, callback=None):  # noqa
+    def push_scope(  # noqa
+        self, callback=None  # type: Optional[Callable[[Scope], None]]
+    ):
+        # type: (...) -> Optional[ContextManager[Scope]]
         """Pushes a new layer on the scope stack. Returns a context manager
         that should be used to pop the scope again.  Alternatively a callback
         can be provided that is executed in the context of the scope.
@@ -390,23 +406,28 @@ def push_scope(self, callback=None):  # noqa
     scope = push_scope
 
     def pop_scope_unsafe(self):
+        # type: () -> Tuple[Optional[Client], Scope]
         """Pops a scope layer from the stack. Try to use the context manager
         `push_scope()` instead."""
         rv = self._stack.pop()
         assert self._stack, "stack must have at least one layer"
         return rv
 
     @overload  # noqa
-    def configure_scope(self):
-        # type: () -> ContextManager[Scope]
+    def configure_scope(self, callback=None):
+        # type: (Optional[None]) -> ContextManager[Scope]
         pass
 
     @overload  # noqa
     def configure_scope(self, callback):
         # type: (Callable[[Scope], None]) -> None
         pass
 
-    def configure_scope(self, callback=None):  # noqa
+    def configure_scope(  # noqa
+        self, callback=None  # type: Optional[Callable[[Scope], None]]
+    ):  # noqa
+        # type: (...) -> Optional[ContextManager[Scope]]
+
         """Reconfigures the scope."""
 
         client, scope = self._stack[-1]
@@ -418,6 +439,7 @@ def configure_scope(self, callback=None):  # noqa
 
         @contextmanager
         def inner():
+            # type: () -> Generator[Scope, None, None]
             if client is not None:
                 yield scope
             else:

sentry_sdk/serializer.py

@@ -15,6 +15,12 @@
     from typing import Dict
     from typing import List
     from typing import Optional
+    from typing import Callable
+    from typing import Union
+    from typing import Generator
+
+    ReprProcessor = Callable[[Any, Dict[str, Any]], Union[NotImplemented, str]]
+    Segment = Union[str, int]
 
 
 if PY2:
@@ -31,10 +37,11 @@
 CYCLE_MARKER = u"<cyclic>"
 
 
-global_repr_processors = []
+global_repr_processors = []  # type: List[ReprProcessor]
 
 
 def add_global_repr_processor(processor):
+    # type: (ReprProcessor) -> None
     global_repr_processors.append(processor)
 
 
@@ -50,8 +57,8 @@ class MetaNode(object):
 
     def __init__(self):
         # type: () -> None
-        self._parent = None
-        self._segment = None
+        self._parent = None  # type: Optional[MetaNode]
+        self._segment = None  # type: Optional[Segment]
         self._depth = 0  # type: int
         self._data = None  # type: Optional[Dict[str, Any]]
         self._is_databag = None  # type: Optional[bool]
@@ -79,6 +86,7 @@ def is_path(self, path):
         return cur._segment is None
 
     def enter(self, segment):
+        # type: (Segment) -> MetaNode
         rv = MetaNode()
         rv._parent = self
         rv._depth = self._depth + 1
@@ -93,7 +101,7 @@ def _create_annotations(self):
         self._data = {}
         if self._parent is not None:
             self._parent._create_annotations()
-            self._parent._data[str(self._segment)] = self._data
+            self._parent._data[str(self._segment)] = self._data  # type: ignore
 
     def annotate(self, **meta):
         # type: (Any) -> None
@@ -150,6 +158,7 @@ def __init__(self):
 
     @contextlib.contextmanager
     def memoize(self, obj):
+        # type: (Any) -> Generator[bool, None, None]
         if id(obj) in self._inner:
             yield True
         else:
@@ -167,6 +176,7 @@ def __init__(self):
 
     @contextlib.contextmanager
     def enter(self, segment):
+        # type: (Segment) -> Generator[None, None, None]
         old_node = self.meta_node
         self.meta_node = self.meta_node.enter(segment)
 
@@ -176,25 +186,29 @@ def enter(self, segment):
             self.meta_node = old_node
 
     def serialize_event(self, obj):
+        # type: (Any) -> Dict[str, Any]
         rv = self._serialize_node(obj)
         if self.meta_node._data is not None:
             rv["_meta"] = self.meta_node._data
         return rv
 
-    def _serialize_node(self, obj, **kwargs):
+    def _serialize_node(self, obj, max_depth=None, max_breadth=None):
+        # type: (Any, Optional[int], Optional[int]) -> Any
         with capture_internal_exceptions():
             with self.memo.memoize(obj) as result:
                 if result:
                     return CYCLE_MARKER
 
-                return self._serialize_node_impl(obj, **kwargs)
+                return self._serialize_node_impl(
+                    obj, max_depth=max_depth, max_breadth=max_breadth
+                )
 
         if self.meta_node.is_databag():
             return u"<failed to serialize, use init(debug=True) to see error logs>"
 
         return None
 
-    def _serialize_node_impl(self, obj, max_depth=None, max_breadth=None):
+    def _serialize_node_impl(self, obj, max_depth, max_breadth):
         # type: (Any, Optional[int], Optional[int]) -> Any
         if max_depth is None and max_breadth is None and self.meta_node.is_databag():
             max_depth = self.meta_node._depth + MAX_DATABAG_DEPTH