chore: add flake8 linter

Author: untitaker

.flake8

@@ -0,0 +1,4 @@
+[flake8]
+max-line-length = 80
+select = C,E,F,W,B,B950
+ignore = E501, E402

sentry_minimal.py

@@ -57,6 +57,7 @@ def get_current_hub():
     from sentry_sdk.hub import Hub
     from sentry_sdk.scope import Scope
 except ImportError:
+
     class Hub(object):
         current = main = None
 

sentry_sdk/__init__.py

@@ -1,2 +1,2 @@
-from .api import *
-from .api import __all__
+from .api import *  # noqa
+from .api import __all__  # noqa

sentry_sdk/_compat.py

@@ -4,25 +4,33 @@
 PY2 = sys.version_info[0] == 2
 
 if PY2:
-    import urlparse
-    text_type = unicode
-    import Queue as queue
-    number_types = (int, long, float)
+    import urlparse # noqa
+
+    text_type = unicode # noqa
+    import Queue as queue # noqa
+
+    number_types = (int, long, float) # noqa
 
     def implements_str(cls):
         cls.__unicode__ = cls.__str__
-        cls.__str__ = lambda x: unicode(x).encode('utf-8')
+        cls.__str__ = lambda x: unicode(x).encode("utf-8") # noqa
         return cls
+
+
 else:
-    import urllib.parse as urlparse
-    import queue
+    import urllib.parse as urlparse # noqa
+    import queue # noqa
+
     text_type = str
-    implements_str = lambda x: x
     number_types = (int, float)
 
+    def implements_str(x):
+        return x
+
 
 def with_metaclass(meta, *bases):
     class metaclass(type):
         def __new__(cls, name, this_bases, d):
             return meta(name, bases, d)
-    return type.__new__(metaclass, 'temporary_class', (), {})
+
+    return type.__new__(metaclass, "temporary_class", (), {})

sentry_sdk/api.py

@@ -1,13 +1,8 @@
-from contextlib import contextmanager
-
 from .hub import Hub
-from .scope import Scope
 from .client import Client
 
 
-
 class _InitGuard(object):
-
     def __init__(self, client):
         self._client = client
 
@@ -29,7 +24,7 @@ def init(*args, **kwargs):
 
 import sentry_minimal
 
-__all__ = ['Hub', 'Scope', 'Client', 'init'] + sentry_minimal.__all__
+__all__ = ["Hub", "Scope", "Client", "init"] + sentry_minimal.__all__
 
 
 for _key in sentry_minimal.__all__:

sentry_sdk/client.py

@@ -11,13 +11,12 @@
 
 
 class Client(object):
-
     def __init__(self, dsn=None, *args, **kwargs):
         if dsn is NO_DSN:
             dsn = None
         else:
             if dsn is None:
-                dsn = os.environ.get('SENTRY_DSN')
+                dsn = os.environ.get("SENTRY_DSN")
             if not dsn:
                 dsn = None
             else:
@@ -43,20 +42,20 @@ def disabled(cls):
         return cls(NO_DSN)
 
     def _prepare_event(self, event, scope):
-        if event.get('event_id') is None:
-            event['event_id'] = uuid.uuid4().hex
+        if event.get("event_id") is None:
+            event["event_id"] = uuid.uuid4().hex
 
         if scope is not None:
             scope.apply_to_event(event)
 
-        for key in 'release', 'environment', 'server_name':
+        for key in "release", "environment", "server_name":
             if event.get(key) is None:
                 event[key] = self.options[key]
-        if event.get('sdk') is None:
-            event['sdk'] = SDK_INFO
+        if event.get("sdk") is None:
+            event["sdk"] = SDK_INFO
 
-        if event.get('platform') is None:
-            event['platform'] = 'python'
+        if event.get("platform") is None:
+            event["platform"] = "python"
 
         event = strip_event(event)
         event = flatten_metadata(event)
@@ -71,7 +70,7 @@ def capture_event(self, event, scope=None):
 
     def drain_events(self, timeout=None):
         if timeout is None:
-            timeout = self.options['drain_timeout']
+            timeout = self.options["drain_timeout"]
         if self._transport is not None:
             self._transport.drain_events(timeout)
 

sentry_sdk/consts.py

@@ -1,17 +1,14 @@
 import socket
 
-VERSION = '0.1'
-DEFAULT_SERVER_NAME = socket.gethostname() if hasattr(socket, 'gethostname') else None
+VERSION = "0.1"
+DEFAULT_SERVER_NAME = socket.gethostname() if hasattr(socket, "gethostname") else None
 DEFAULT_OPTIONS = {
-    'with_locals': True,
-    'max_breadcrumbs': 100,
-    'release': None,
-    'environment': None,
-    'server_name': DEFAULT_SERVER_NAME,
-    'drain_timeout': 2.0,
+    "with_locals": True,
+    "max_breadcrumbs": 100,
+    "release": None,
+    "environment": None,
+    "server_name": DEFAULT_SERVER_NAME,
+    "drain_timeout": 2.0,
 }
 
-SDK_INFO = {
-    'name': 'sentry-python',
-    'version': VERSION,
-}
+SDK_INFO = {"name": "sentry-python", "version": VERSION}

sentry_sdk/hub.py

@@ -1,19 +1,21 @@
 import sys
 import copy
-import linecache
 from contextlib import contextmanager
 
 from ._compat import with_metaclass
 from .scope import Scope
-from .utils import exceptions_from_error_tuple, create_event, \
-    skip_internal_frames, ContextVar
+from .utils import (
+    exceptions_from_error_tuple,
+    create_event,
+    skip_internal_frames,
+    ContextVar,
+)
 
 
-_local = ContextVar('sentry_current_hub')
+_local = ContextVar("sentry_current_hub")
 
 
 class HubMeta(type):
-
     @property
     def current(self):
         rv = _local.get(None)
@@ -28,7 +30,6 @@ def main(self):
 
 
 class _HubManager(object):
-
     def __init__(self, hub):
         self._old = Hub.current
         _local.set(hub)
@@ -38,7 +39,6 @@ def __exit__(self, exc_type, exc_value, tb):
 
 
 class _ScopeManager(object):
-
     def __init__(self, hub, layer):
         self._hub = hub
         self._layer = layer
@@ -47,11 +47,10 @@ def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_value, tb):
-        assert self._hub._stack.pop() == self._layer, 'popped wrong scope'
+        assert self._hub._stack.pop() == self._layer, "popped wrong scope"
 
 
 class Hub(with_metaclass(HubMeta)):
-
     def __init__(self, client_or_hub=None, scope=None):
         if isinstance(client_or_hub, Hub):
             hub = client_or_hub
@@ -92,18 +91,18 @@ def capture_event(self, event):
         client, scope = self._stack[-1]
         if client is not None:
             client.capture_event(event, scope)
-            return event.get('event_id')
+            return event.get("event_id")
 
     def capture_message(self, message, level=None):
         """Captures a message."""
         if self.client is None:
             return
         if level is None:
-            level = 'info'
+            level = "info"
         event = create_event()
-        event['message'] = message
+        event["message"] = message
         if level is not None:
-            event['level'] = level
+            event["level"] = level
         return self.capture_event(event)
 
     def capture_exception(self, error=None):
@@ -116,7 +115,7 @@ def capture_exception(self, error=None):
         elif isinstance(error, tuple) and len(error) == 3:
             exc_type, exc_value, tb = error
         else:
-            tb = getattr(error, '__traceback__', None)
+            tb = getattr(error, "__traceback__", None)
             if tb is not None:
                 exc_type = type(error)
                 exc_value = error
@@ -132,9 +131,10 @@ def capture_exception(self, error=None):
 
         event = create_event()
         try:
-            event['exception'] = {
-                'values': exceptions_from_error_tuple(
-                    exc_type, exc_value, tb, client.options['with_locals'])
+            event["exception"] = {
+                "values": exceptions_from_error_tuple(
+                    exc_type, exc_value, tb, client.options["with_locals"]
+                )
             }
             return self.capture_event(event)
         except Exception:
@@ -154,7 +154,7 @@ def add_breadcrumb(self, crumb):
             crumb = crumb()
         if crumb is not None:
             scope._breadcrumbs.append(crumb)
-        while len(scope._breadcrumbs) >= client.options['max_breadcrumbs']:
+        while len(scope._breadcrumbs) >= client.options["max_breadcrumbs"]:
             scope._breadcrumbs.popleft()
 
     def add_event_processor(self, factory):

sentry_sdk/integrations/_wsgi.py

@@ -2,6 +2,6 @@ def get_environ(environ):
     """
     Returns our whitelisted environment variables.
     """
-    for key in ('REMOTE_ADDR', 'SERVER_NAME', 'SERVER_PORT'):
+    for key in ("REMOTE_ADDR", "SERVER_NAME", "SERVER_PORT"):
         if key in environ:
             yield key, environ[key]

sentry_sdk/integrations/celery.py

@@ -1,11 +1,8 @@
 from __future__ import absolute_import
 
-from celery.signals import (
-    after_setup_logger, task_failure, task_prerun, task_postrun
-)
+from celery.signals import task_failure, task_prerun, task_postrun
 
 from sentry_sdk import get_current_hub, configure_scope, capture_exception
-from sentry_sdk.utils import ContextVar
 
 
 def install():
@@ -15,19 +12,15 @@ def install():
 
 
 def _process_failure_signal(sender, task_id, einfo, **kw):
-    if hasattr(sender, 'throws') and isinstance(einfo.exception, sender.throws):
+    if hasattr(sender, "throws") and isinstance(einfo.exception, sender.throws):
         return
 
     capture_exception(einfo.exc_info)
 
 
-_task_scope = ContextVar('sentry_celery_task_scope')
-
-
 def _handle_task_prerun(sender, task, **kw):
     try:
-        assert _task_scope.get(None) is None, 'race condition'
-        _task_scope.set(get_current_hub().push_scope().__enter__())
+        get_current_hub().push_scope()
 
         with configure_scope() as scope:
             scope.transaction = task.name
@@ -36,10 +29,4 @@ def _handle_task_prerun(sender, task, **kw):
 
 
 def _handle_task_postrun(sender, task_id, task, **kw):
-    try:
-        val = _task_scope.get(None)
-        assert val is not None, 'race condition'
-        val.__exit__(None, None, None)
-        _task_scope.set(None)
-    except Exception:
-        get_current_hub().capture_internal_exception()
+    get_current_hub().pop_scope_unsafe()