Applied fixes from pre-commit

Author: agronholm

.readthedocs.yml

@@ -1,7 +1,7 @@
 version: 2
 formats: [htmlzip, pdf]
 python:
-   version: "3.7"
+   version: "3.8"
    install:
       - method: pip
         path: .

docs/conf.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
-import pkg_resources
+from importlib.metadata import get_version
 
+from packaging.version import parse
 
 extensions = [
     'sphinx.ext.autodoc',
@@ -17,7 +18,7 @@
 author = 'Alex Grönholm'
 copyright = '2017, ' + author
 
-v = pkg_resources.get_distribution(project).parsed_version
+v = parse(get_version(project))
 version = v.base_version
 release = v.public
 
@@ -33,11 +34,10 @@
 htmlhelp_basename = project.replace('-', '') + 'doc'
 
 extlinks = {
-    'github': ('https://github.com/asphalt-framework/%s/tree/%s/%%s' % (project, version),
-               None)
+    'github': (f'https://github.com/asphalt-framework/{project}/tree/{version}/%s', None)
 }
 
 intersphinx_mapping = {
     'python': ('https://docs.python.org/3/', None),
-    'asphalt': ('http://asphalt.readthedocs.io/en/latest/', None)
+    'asphalt': ('https://asphalt.readthedocs.io/en/latest/', None)
 }

docs/extending.rst

@@ -71,4 +71,3 @@ And then during the startup of your component::
         async def start(ctx):
             ...
             ctx.add_resource(MyExtrasProvider(), types=[ExtrasProvider])
-

src/asphalt/exceptions/__init__.py

@@ -1,20 +1,21 @@
+from __future__ import annotations
+
 import inspect
 import logging
 import sys
-from typing import Union, Dict, Any  # noqa: F401
+from typing import Any
 
-from asphalt.core import Context, qualified_name, merge_config
-from typeguard import check_argument_types
+from asphalt.core import Context, merge_config, qualified_name
 
-from asphalt.exceptions.api import ExtrasProvider
+from asphalt.exceptions.api import ExceptionReporter, ExtrasProvider
 
 __all__ = ('report_exception',)
 
 module_logger = logging.getLogger(__name__)
 
 
 def report_exception(ctx: Context, message: str, exception: BaseException = None, *,
-                     logger: Union[logging.Logger, str, bool] = True) -> None:
+                     logger: logging.Logger | str | bool = True) -> None:
     """
     Report an exception to all exception reporters in the given context (and optionally log it too)
 
@@ -27,35 +28,35 @@ def report_exception(ctx: Context, message: str, exception: BaseException = None
         the module where the exception was raised (or ``False`` to skip logging the exception)
 
     """
-    from asphalt.exceptions.api import ExceptionReporter
-
-    assert check_argument_types()
-
     if not exception:
         exception = sys.exc_info()[1]
         if not exception:
             raise ValueError('missing "exception" parameter and no current exception present in '
                              'sys.exc_info()')
 
+    actual_logger: logging.Logger | None
     if isinstance(logger, bool):
-        if logger:
-            frame = exception.__traceback__.tb_frame
+        tb = exception.__traceback__
+        if logger and tb:
+            frame = tb.tb_frame
             module = inspect.getmodule(frame)
-            if module:
-                logger = logging.getLogger(module.__spec__.name)
+            if module and module.__spec__:
+                actual_logger = logging.getLogger(module.__spec__.name)
             else:  # pragma: no cover
-                logger = logging.getLogger(frame.f_globals['__name__'])
+                actual_logger = logging.getLogger(frame.f_globals['__name__'])
         else:
-            logger = None
+            actual_logger = None
     elif isinstance(logger, str):
-        logger = logging.getLogger(logger)
+        actual_logger = logging.getLogger(logger)
+    else:
+        actual_logger = logger
 
-    if logger:
-        logger.error(message, exc_info=exception)
+    if actual_logger:
+        actual_logger.error(message, exc_info=exception)
 
     extras_providers = ctx.get_resources(ExtrasProvider)
     for reporter in ctx.get_resources(ExceptionReporter):
-        extra = {}  # type: Dict[str, Any]
+        extra: dict[str, Any] = {}
         for provider in extras_providers:
             try:
                 new_extra = provider.get_extras(ctx, reporter)

src/asphalt/exceptions/api.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from abc import ABCMeta, abstractmethod
-from typing import Dict, Any, Optional
+from typing import Any
 
 from asphalt.core import Context
 
@@ -14,7 +16,7 @@ class ExceptionReporter(metaclass=ABCMeta):
 
     @abstractmethod
     def report_exception(self, ctx: Context, exception: BaseException, message: str,
-                         extra: Dict[str, Any]) -> None:
+                         extra: dict[str, Any]) -> None:
         """
         Report the given exception to an external service.
 
@@ -41,7 +43,7 @@ class ExtrasProvider(metaclass=ABCMeta):
     """
 
     @abstractmethod
-    def get_extras(self, ctx: Context, reporter: ExceptionReporter) -> Optional[Dict[str, Any]]:
+    def get_extras(self, ctx: Context, reporter: ExceptionReporter) -> dict[str, Any] | None:
         """
         Return context specific extras for the given exception reporter backend.
 

src/asphalt/exceptions/component.py

@@ -1,6 +1,9 @@
+from __future__ import annotations
+
 import logging
+from asyncio import AbstractEventLoop
 from functools import partial
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, AsyncIterator, Dict, Optional
 
 from asphalt.core import (
     Component, Context, PluginContainer, context_teardown, merge_config, qualified_name)
@@ -13,7 +16,8 @@
 logger = logging.getLogger(__name__)
 
 
-def default_exception_handler(loop, context: Dict[str, Any], *, ctx: Context) -> None:
+def default_exception_handler(loop: AbstractEventLoop, context: dict[str, Any], *,
+                              ctx: Context) -> None:
     report_exception(ctx, context['message'], context['exception'])
 
 
@@ -55,15 +59,15 @@ def __init__(self, reporters: Dict[str, Optional[Dict[str, Any]]] = None,
         if not reporters:
             reporters = {'default': default_args}
 
-        self.reporters: List[Tuple] = []
+        self.reporters: list[tuple] = []
         for resource_name, config in reporters.items():
-            config = merge_config(default_args, config or {})
-            type_ = config.pop('backend', resource_name)
-            serializer = reporter_backends.create_object(type_, **config)
+            merged_config = merge_config(default_args, config or {})
+            type_ = merged_config.pop('backend', resource_name)
+            serializer = reporter_backends.create_object(type_, **merged_config)
             self.reporters.append((resource_name, serializer))
 
     @context_teardown
-    async def start(self, ctx: Context) -> None:
+    async def start(self, ctx: Context) -> AsyncIterator[None]:
         for resource_name, reporter in self.reporters:
             types = [ExceptionReporter, type(reporter)]
             ctx.add_resource(reporter, resource_name, types=types)

src/asphalt/exceptions/reporters/raygun.py

@@ -1,4 +1,6 @@
-from typing import Dict, Any
+from __future__ import annotations
+
+from typing import Any
 
 from asphalt.core import Context
 from raygun4py.raygunprovider import RaygunSender
@@ -27,5 +29,5 @@ def __init__(self, api_key: str, **config) -> None:
         self.client = RaygunSender(api_key, config)
 
     def report_exception(self, ctx: Context, exception: BaseException, message: str,
-                         extra: Dict[str, Any]) -> None:
+                         extra: dict[str, Any]) -> None:
         self.client.send_exception(exception, **extra)

src/asphalt/exceptions/reporters/sentry.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 import logging
-from typing import Dict, Any
+from typing import Any
 
 from asphalt.core import Context
 from raven import Client
@@ -41,6 +43,6 @@ def __init__(self, **client_args) -> None:
         self.client = Client(**client_args)
 
     def report_exception(self, ctx: Context, exception: BaseException, message: str,
-                         extra: Dict[str, Any]) -> None:
+                         extra: dict[str, Any]) -> None:
         exc_info = type(exception), exception, exception.__traceback__
         self.client.captureException(exc_info, message=message, **extra)

tests/__init__.py

@@ -1,12 +1,11 @@
-import logging
-
 import gc
+import logging
 from asyncio import sleep
 from collections import OrderedDict
 
 import pytest
-
 from asphalt.core.context import Context
+
 from asphalt.exceptions.api import ExceptionReporter
 from asphalt.exceptions.component import ExceptionReporterComponent
 
@@ -44,9 +43,9 @@ def report_exception(self, ctx: Context, exception: BaseException, message: str,
         assert len(messages) == 2
 
     assert messages[0] == ('Configured exception reporter (dummy1; '
-                           'class=test_component.test_start.<locals>.DummyReporter)')
+                           'class=tests.test_component.test_start.<locals>.DummyReporter)')
     assert messages[1] == ('Configured exception reporter (dummy2; '
-                           'class=test_component.test_start.<locals>.DummyReporter2)')
+                           'class=tests.test_component.test_start.<locals>.DummyReporter2)')
 
 
 @pytest.mark.asyncio
@@ -56,6 +55,8 @@ async def test_default_exception_handler(event_loop):
     exception handler.
 
     """
+    reported_exception = reported_message = None
+
     async def fail_task():
         return 1 / 0
 
@@ -66,7 +67,6 @@ def report_exception(self, ctx: Context, exception: BaseException, message: str,
             reported_exception = exception
             reported_message = message
 
-    reported_exception = reported_message = None
     async with Context() as ctx:
         component = ExceptionReporterComponent(backend=DummyExceptionReporter)
         await component.start(ctx)