enable pre-commit (#1355)

* enable pre-commit

* use extend-ignore for flake8

* manual flake8 fixes

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Update kombu/__init__.py

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

119 files changed, 407 insertions, 442 deletions

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 00000000..057c78f4
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,29 @@
+repos:
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v2.21.2
+    hooks:
+      - id: pyupgrade
+        args: ["--py36-plus"]
+
+  - repo: https://gitlab.com/pycqa/flake8
+    rev: 3.9.2
+    hooks:
+      - id: flake8
+
+  - repo: https://github.com/asottile/yesqa
+    rev: v1.2.3
+    hooks:
+      - id: yesqa
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.0.1
+    hooks:
+      - id: check-merge-conflict
+      - id: check-toml
+      - id: check-yaml
+      - id: mixed-line-ending
+
+  - repo: https://github.com/pycqa/isort
+    rev: 5.9.2
+    hooks:
+      - id: isort
diff --git a/conftest.py b/conftest.py
index f6d7d655..ab0a5d90 100644
--- a/conftest.py
+++ b/conftest.py
@@ -1,17 +1,29 @@
 import pytest
+
+
 def pytest_addoption(parser):
-    parser.addoption("-E", action="append", metavar="NAME",
-        help="only run tests matching the environment NAME.")
+    parser.addoption(
+        "-E",
+        action="append",
+        metavar="NAME",
+        help="only run tests matching the environment NAME.",
+    )
+
 
 def pytest_configure(config):
     # register an additional marker
-    config.addinivalue_line("markers",
-        "env(name): mark test to run only on named environment")
+    config.addinivalue_line(
+        "markers",
+        "env(name): mark test to run only on named environment",
+    )
+
 
 def pytest_runtest_setup(item):
     envnames = [mark.args[0] for mark in item.iter_markers(name='env')]
     if envnames:
-        if item.config.getoption("-E") is None or len(set(item.config.getoption("-E")) & set(envnames)) == 0:
+        if (
+            item.config.getoption("-E") is None
+            or len(set(item.config.getoption("-E")) & set(envnames)) == 0
+        ):
             # We skip test if does not mentioned by -E param
             pytest.skip("test requires env in %r" % envnames)
-
diff --git a/examples/complete_receive.py b/examples/complete_receive.py
index f122262a..21903c59 100644
--- a/examples/complete_receive.py
+++ b/examples/complete_receive.py
@@ -6,7 +6,7 @@ and exits.
 
 from pprint import pformat
 
-from kombu import Connection, Exchange, Queue, Consumer, eventloop
+from kombu import Connection, Consumer, Exchange, Queue, eventloop
 
 #: By default messages sent to exchanges are persistent (delivery_mode=2),
 #: and queues and exchanges are durable.
@@ -21,10 +21,11 @@ def pretty(obj):
 #: This is the callback applied when a message is received.
 def handle_message(body, message):
     print(f'Received message: {body!r}')
-    print('  properties:\n{}'.format(pretty(message.properties)))
-    print('  delivery_info:\n{}'.format(pretty(message.delivery_info)))
+    print(f'  properties:\n{pretty(message.properties)}')
+    print(f'  delivery_info:\n{pretty(message.delivery_info)}')
     message.ack()
 
+
 #: Create a connection and a channel.
 #: If hostname, userid, password and virtual_host is not specified
 #: the values below are the default, but listed here so it can
diff --git a/examples/complete_send.py b/examples/complete_send.py
index 90bd3f9e..d4643e59 100644
--- a/examples/complete_send.py
+++ b/examples/complete_send.py
@@ -6,7 +6,7 @@ You can use `complete_receive.py` to receive the message sent.
 
 """
 
-from kombu import Connection, Producer, Exchange, Queue
+from kombu import Connection, Exchange, Producer, Queue
 
 #: By default messages sent to exchanges are persistent (delivery_mode=2),
 #: and queues and exchanges are durable.
@@ -25,7 +25,10 @@ with Connection('amqp://guest:guest@localhost:5672//') as connection:
     #: Publish the message using the json serializer (which is the default),
     #: and zlib compression.  The kombu consumer will automatically detect
     #: encoding, serialization and compression used and decode accordingly.
-    producer.publish({'hello': 'world'},
-                     exchange=exchange,
-                     routing_key='kombu_demo',
-                     serializer='json', compression='zlib')
+    producer.publish(
+        {'hello': 'world'},
+        exchange=exchange,
+        routing_key='kombu_demo',
+        serializer='json',
+        compression='zlib',
+    )
diff --git a/examples/experimental/async_consume.py b/examples/experimental/async_consume.py
index aebb974b..5f70b4ed 100644
--- a/examples/experimental/async_consume.py
+++ b/examples/experimental/async_consume.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 
-from kombu import Connection, Exchange, Queue, Producer, Consumer
+from kombu import Connection, Consumer, Exchange, Producer, Queue
 from kombu.asynchronous import Hub
 
 hub = Hub()
diff --git a/examples/hello_consumer.py b/examples/hello_consumer.py
index e633e02d..3a0d9f06 100644
--- a/examples/hello_consumer.py
+++ b/examples/hello_consumer.py
@@ -1,5 +1,4 @@
-from kombu import Connection  # noqa
-
+from kombu import Connection
 
 with Connection('amqp://guest:guest@localhost:5672//') as conn:
     simple_queue = conn.SimpleQueue('simple_queue')
diff --git a/examples/hello_publisher.py b/examples/hello_publisher.py
index d6a49048..48342800 100644
--- a/examples/hello_publisher.py
+++ b/examples/hello_publisher.py
@@ -2,7 +2,6 @@ import datetime
 
 from kombu import Connection
 
-
 with Connection('amqp://guest:guest@localhost:5672//') as conn:
     simple_queue = conn.SimpleQueue('simple_queue')
     message = f'helloworld, sent at {datetime.datetime.today()}'
diff --git a/examples/memory_transport.py b/examples/memory_transport.py
index 662c94a0..8d667b81 100644
--- a/examples/memory_transport.py
+++ b/examples/memory_transport.py
@@ -3,7 +3,7 @@ Example that use memory transport for message produce.
 """
 import time
 
-from kombu import Connection, Exchange, Queue, Consumer
+from kombu import Connection, Consumer, Exchange, Queue
 
 media_exchange = Exchange('media', 'direct')
 video_queue = Queue('video', exchange=media_exchange, routing_key='video')
@@ -19,6 +19,11 @@ connection = Connection("memory:///")
 consumer = Consumer(connection, task_queues, callbacks=[handle_message])
 
 producer = connection.Producer(serializer='json')
-producer.publish({"foo": "bar"}, exchange=media_exchange, routing_key='video', declare=task_queues)
+producer.publish(
+    {"foo": "bar"},
+    exchange=media_exchange,
+    routing_key='video',
+    declare=task_queues,
+)
 consumer.consume()
 connection.drain_events()
diff --git a/examples/rpc-tut6/rpc_client.py b/examples/rpc-tut6/rpc_client.py
index 6ed5833f..6b1d509b 100644
--- a/examples/rpc-tut6/rpc_client.py
+++ b/examples/rpc-tut6/rpc_client.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 
-from kombu import Connection, Producer, Consumer, Queue, uuid
+from kombu import Connection, Consumer, Producer, Queue, uuid
 
 
 class FibonacciRpcClient:
diff --git a/examples/simple_eventlet_receive.py b/examples/simple_eventlet_receive.py
index 18a3f6bb..33f09d80 100644
--- a/examples/simple_eventlet_receive.py
+++ b/examples/simple_eventlet_receive.py
@@ -37,4 +37,5 @@ def wait_many(timeout=1):
                     message.ack()
                     print(message.payload)
 
+
 eventlet.spawn(wait_many).wait()
diff --git a/examples/simple_task_queue/client.py b/examples/simple_task_queue/client.py
index e19b9476..bc2d180f 100644
--- a/examples/simple_task_queue/client.py
+++ b/examples/simple_task_queue/client.py
@@ -21,8 +21,10 @@ def send_as_task(connection, fun, args=(), kwargs={}, priority='mid'):
                          declare=[task_exchange],
                          routing_key=routing_key)
 
+
 if __name__ == '__main__':
     from kombu import Connection
+
     from .tasks import hello_task
 
     connection = Connection('amqp://guest:guest@localhost:5672//')
diff --git a/examples/simple_task_queue/worker.py b/examples/simple_task_queue/worker.py
index 14064ccf..66ad9c30 100644
--- a/examples/simple_task_queue/worker.py
+++ b/examples/simple_task_queue/worker.py
@@ -1,5 +1,5 @@
-from kombu.mixins import ConsumerMixin
 from kombu.log import get_logger
+from kombu.mixins import ConsumerMixin
 from kombu.utils.functional import reprcall
 
 from .queues import task_queues
@@ -28,9 +28,11 @@ class Worker(ConsumerMixin):
             logger.error('task raised exception: %r', exc)
         message.ack()
 
+
 if __name__ == '__main__':
     from kombu import Connection
     from kombu.utils.debug import setup_logging
+
     # setup root logger
     setup_logging(loglevel='INFO', loggers=[''])
 
diff --git a/kombu/__init__.py b/kombu/__init__.py
index 9e610abe..8710babb 100644
--- a/kombu/__init__.py
+++ b/kombu/__init__.py
@@ -3,7 +3,7 @@
 import os
 import re
 import sys
-from collections import namedtuple  # noqa
+from collections import namedtuple
 
 __version__ = '5.1.0'
 __author__ = 'Ask Solem'
@@ -32,17 +32,15 @@ if STATICA_HACK:  # pragma: no cover
     # This is never executed, but tricks static analyzers (PyDev, PyCharm,
     # pylint, etc.) into knowing the types of these symbols, and what
     # they contain.
-    from kombu.connection import Connection, BrokerConnection   # noqa
-    from kombu.entity import Exchange, Queue, binding           # noqa
-    from kombu.message import Message                           # noqa
-    from kombu.messaging import Consumer, Producer              # noqa
-    from kombu.pools import connections, producers              # noqa
-    from kombu.utils.url import parse_url                       # noqa
-    from kombu.common import eventloop, uuid                    # noqa
-    from kombu.serialization import (                           # noqa
-        enable_insecure_serializers,
-        disable_insecure_serializers,
-    )
+    from kombu.common import eventloop, uuid  # noqa
+    from kombu.connection import BrokerConnection, Connection  # noqa
+    from kombu.entity import Exchange, Queue, binding  # noqa
+    from kombu.message import Message  # noqa
+    from kombu.messaging import Consumer, Producer  # noqa
+    from kombu.pools import connections, producers  # noqa
+    from kombu.serialization import disable_insecure_serializers  # noqa
+    from kombu.serialization import enable_insecure_serializers  # noqa
+    from kombu.utils.url import parse_url  # noqa
 
 # Lazy loading.
 # - See werkzeug/__init__.py for the rationale behind this.
diff --git a/kombu/asynchronous/__init__.py b/kombu/asynchronous/__init__.py
index 4028068f..fb264aa5 100644
--- a/kombu/asynchronous/__init__.py
+++ b/kombu/asynchronous/__init__.py
@@ -1,7 +1,7 @@
 """Event loop."""
 
-from .hub import Hub, get_event_loop, set_event_loop
+from kombu.utils.eventio import ERR, READ, WRITE
 
-from kombu.utils.eventio import READ, WRITE, ERR
+from .hub import Hub, get_event_loop, set_event_loop
 
 __all__ = ('READ', 'WRITE', 'ERR', 'Hub', 'get_event_loop', 'set_event_loop')
diff --git a/kombu/asynchronous/aws/connection.py b/kombu/asynchronous/aws/connection.py
index 18c1452f..6f087e8f 100644
--- a/kombu/asynchronous/aws/connection.py
+++ b/kombu/asynchronous/aws/connection.py
@@ -1,15 +1,15 @@
 """Amazon AWS Connection."""
 
+from email import message_from_bytes
+from email.mime.message import MIMEMessage
+
 from vine import promise, transform
 
 from kombu.asynchronous.aws.ext import AWSRequest, get_response
-
 from kombu.asynchronous.http import Headers, Request, get_client
 
-from email import message_from_bytes
-from email.mime.message import MIMEMessage
 
-def message_from_headers(hdr):  # noqa
+def message_from_headers(hdr):
     bs = "\r\n".join("{}: {}".format(*h) for h in hdr)
     return message_from_bytes(bs.encode())
 
@@ -129,7 +129,7 @@ class AsyncHTTPSConnection:
 class AsyncConnection:
     """Async AWS Connection."""
 
-    def __init__(self, sqs_connection, http_client=None, **kwargs):  # noqa
+    def __init__(self, sqs_connection, http_client=None, **kwargs):
         self.sqs_connection = sqs_connection
         self._httpclient = http_client or get_client()
 
@@ -184,7 +184,7 @@ class AsyncAWSQueryConnection(AsyncConnection):
         params = params_.copy()
         if operation:
             params['Action'] = operation
-        signer = self.sqs_connection._request_signer  # noqa
+        signer = self.sqs_connection._request_signer
 
         # defaults for non-get
         signing_type = 'standard'
@@ -225,7 +225,7 @@ class AsyncAWSQueryConnection(AsyncConnection):
             ),
         )
 
-    def _on_list_ready(self, parent, markers, operation, response):  # noqa
+    def _on_list_ready(self, parent, markers, operation, response):
         service_model = self.sqs_connection.meta.service_model
         if response.status == self.STATUS_CODE_OK:
             _, parsed = get_response(
@@ -243,7 +243,7 @@ class AsyncAWSQueryConnection(AsyncConnection):
         else:
             raise self._for_status(response, response.read())
 
-    def _on_obj_ready(self, parent, operation, response):  # noqa
+    def _on_obj_ready(self, parent, operation, response):
         service_model = self.sqs_connection.meta.service_model
         if response.status == self.STATUS_CODE_OK:
             _, parsed = get_response(
@@ -253,7 +253,7 @@ class AsyncAWSQueryConnection(AsyncConnection):
         else:
             raise self._for_status(response, response.read())
 
-    def _on_status_ready(self, parent, operation, response):  # noqa
+    def _on_status_ready(self, parent, operation, response):
         service_model = self.sqs_connection.meta.service_model
         if response.status == self.STATUS_CODE_OK:
             httpres, _ = get_response(
diff --git a/kombu/asynchronous/aws/sqs/connection.py b/kombu/asynchronous/aws/sqs/connection.py
index 2a878601..0a524ba0 100644
--- a/kombu/asynchronous/aws/sqs/connection.py
+++ b/kombu/asynchronous/aws/sqs/connection.py
@@ -8,7 +8,6 @@ from .ext import boto3
 from .message import AsyncMessage
 from .queue import AsyncQueue
 
-
 __all__ = ('AsyncSQSConnection',)
 
 
@@ -84,7 +83,7 @@ class AsyncSQSConnection(AsyncAWSQueryConnection):
     def delete_message_batch(self, queue, messages, callback=None):
         params = {}
         for i, m in enumerate(messages):
-            prefix = 'DeleteMessageBatchRequestEntry.{}'.format(i + 1)
+            prefix = f'DeleteMessageBatchRequestEntry.{i + 1}'
             params.update({
                 f'{prefix}.Id': m.id,
                 f'{prefix}.ReceiptHandle': m.receipt_handle,
@@ -114,7 +113,7 @@ class AsyncSQSConnection(AsyncAWSQueryConnection):
     def send_message_batch(self, queue, messages, callback=None):
         params = {}
         for i, msg in enumerate(messages):
-            prefix = 'SendMessageBatchRequestEntry.{}'.format(i + 1)
+            prefix = f'SendMessageBatchRequestEntry.{i + 1}'
             params.update({
                 f'{prefix}.Id': msg[0],
                 f'{prefix}.MessageBody': msg[1],
@@ -137,7 +136,7 @@ class AsyncSQSConnection(AsyncAWSQueryConnection):
     def change_message_visibility_batch(self, queue, messages, callback=None):
         params = {}
         for i, t in enumerate(messages):
-            pre = 'ChangeMessageVisibilityBatchRequestEntry.{}'.format(i + 1)
+            pre = f'ChangeMessageVisibilityBatchRequestEntry.{i + 1}'
             params.update({
                 f'{pre}.Id': t[0].id,
                 f'{pre}.ReceiptHandle': t[0].receipt_handle,
diff --git a/kombu/asynchronous/debug.py b/kombu/asynchronous/debug.py
index a77ade3b..4fabb452 100644
--- a/kombu/asynchronous/debug.py
+++ b/kombu/asynchronous/debug.py
@@ -1,6 +1,6 @@
 """Event-loop debugging tools."""
 
-from kombu.utils.eventio import READ, WRITE, ERR
+from kombu.utils.eventio import ERR, READ, WRITE
 from kombu.utils.functional import reprcall
 
 
@@ -40,13 +40,13 @@ def repr_events(h, events):
 
 def repr_readers(h):
     """Return description of pending readers."""
-    return ['({}){}->{}'.format(fd, _rcb(cb), repr_flag(READ | ERR))
+    return [f'({fd}){_rcb(cb)}->{repr_flag(READ | ERR)}'
             for fd, cb in h.readers.items()]
 
 
 def repr_writers(h):
     """Return description of pending writers."""
-    return ['({}){}->{}'.format(fd, _rcb(cb), repr_flag(WRITE))
+    return [f'({fd}){_rcb(cb)}->{repr_flag(WRITE)}'
             for fd, cb in h.writers.items()]
 
 
diff --git a/kombu/asynchronous/http/__init__.py b/kombu/asynchronous/http/__init__.py
index e776977d..1c45ebca 100644
--- a/kombu/asynchronous/http/__init__.py
+++ b/kombu/asynchronous/http/__init__.py
@@ -1,6 +1,6 @@
 from kombu.asynchronous import get_event_loop
 
-from .base import Request, Headers, Response
+from .base import Headers, Request, Response
 
 __all__ = ('Client', 'Headers', 'Response', 'Request')
 
diff --git a/kombu/asynchronous/http/base.py b/kombu/asynchronous/http/base.py
index 4195ae7f..e8d5043b 100644
--- a/kombu/asynchronous/http/base.py
+++ b/kombu/asynchronous/http/base.py
@@ -3,14 +3,13 @@
 import sys
 from http.client import responses
 
-from vine import Thenable, promise, maybe_promise
+from vine import Thenable, maybe_promise, promise
 
 from kombu.exceptions import HttpError
 from kombu.utils.compat import coro
 from kombu.utils.encoding import bytes_to_str
 from kombu.utils.functional import maybe_list, memoize
 
-
 __all__ = ('Headers', 'Response', 'Request')
 
 PYPY = hasattr(sys, 'pypy_version_info')
diff --git a/kombu/asynchronous/http/curl.py b/kombu/asynchronous/http/curl.py
index df9fc7d8..ee70f3c6 100644
--- a/kombu/asynchronous/http/curl.py
+++ b/kombu/asynchronous/http/curl.py
@@ -12,13 +12,13 @@ from kombu.utils.encoding import bytes_to_str
 from .base import BaseClient
 
 try:
-    import pycurl  # noqa
+    import pycurl
 except ImportError:  # pragma: no cover
-    pycurl = Curl = METH_TO_CURL = None  # noqa
+    pycurl = Curl = METH_TO_CURL = None
 else:
-    from pycurl import Curl  # noqa
+    from pycurl import Curl
 
-    METH_TO_CURL = {  # noqa
+    METH_TO_CURL = {
         'GET': pycurl.HTTPGET,
         'POST': pycurl.POST,
         'PUT': pycurl.UPLOAD,
diff --git a/kombu/asynchronous/hub.py b/kombu/asynchronous/hub.py
index c6846057..b1f7e241 100644
--- a/kombu/asynchronous/hub.py
+++ b/kombu/asynchronous/hub.py
@@ -4,13 +4,14 @@ import errno
 from contextlib import contextmanager
 from queue import Empty
 from time import sleep
-from types import GeneratorType as generator  # noqa
+from types import GeneratorType as generator
+
+from vine import Thenable, promise
 
 from kombu.log import get_logger
 from kombu.utils.compat import fileno
 from kombu.utils.eventio import ERR, READ, WRITE, poll
 from kombu.utils.objects import cached_property
-from vine import Thenable, promise
 
 from .timer import Timer
 
diff --git a/kombu/asynchronous/timer.py b/kombu/asynchronous/timer.py
index 70951f11..21ad37c1 100644
--- a/kombu/asynchronous/timer.py
+++ b/kombu/asynchronous/timer.py
@@ -2,17 +2,16 @@
 
 import heapq
 import sys
-
 from collections import namedtuple
 from datetime import datetime
 from functools import total_ordering
-from weakref import proxy as weakrefproxy
 from time import monotonic
+from time import time as _time
+from weakref import proxy as weakrefproxy
 
 from vine.utils import wraps
 
 from kombu.log import get_logger
-from time import time as _time
 
 try:
     from pytz import utc
diff --git a/kombu/clocks.py b/kombu/clocks.py
index e2a3baef..3c152720 100644
--- a/kombu/clocks.py
+++ b/kombu/clocks.py
@@ -1,8 +1,8 @@
 """Logical Clocks and Synchronization."""
 
-from threading import Lock
 from itertools import islice
 from operator import itemgetter
+from threading import Lock
 
 __all__ = ('LamportClock', 'timetuple')
 
diff --git a/kombu/common.py b/kombu/common.py
index 44bff419..08bc1aff 100644
--- a/kombu/common.py
+++ b/kombu/common.py
@@ -3,12 +3,11 @@
 import os
 import socket
 import threading
-
 from collections import deque
 from contextlib import contextmanager
 from functools import partial
 from itertools import count
-from uuid import uuid5, uuid4, uuid3, NAMESPACE_OID
+from uuid import NAMESPACE_OID, uuid3, uuid4, uuid5
 
 from amqp import ChannelError, RecoverableConnectionError
 
@@ -17,7 +16,6 @@ from .log import get_logger
 from .serialization import registry as serializers
 from .utils.uuid import uuid
 
-
 __all__ = ('Broadcast', 'maybe_declare', 'uuid',
            'itermessages', 'send_reply',
            'collect_replies', 'insured', 'drain_consumer',
diff --git a/kombu/connection.py b/kombu/connection.py
index e5b601fa..4121f1fb 100644
--- a/kombu/connection.py
+++ b/kombu/connection.py
@@ -2,13 +2,11 @@
 
 import os
 import socket
-
 from collections import OrderedDict
 from contextlib import contextmanager
 from itertools import count, cycle
 from operator import itemgetter
 
-
 try:
     from ssl import CERT_NONE
     ssl_available = True
@@ -26,7 +24,7 @@ from .transport import get_transport_cls, supports_librabbitmq
 from .utils.collections import HashedSeq
 from .utils.functional import dictfilter, lazy, retry_over_time, shufflecycle
 from .utils.objects import cached_property
-from .utils.url import as_url, parse_url, quote, urlparse, maybe_sanitize_url
+from .utils.url import as_url, maybe_sanitize_url, parse_url, quote, urlparse
 
 __all__ = ('Connection', 'ConnectionPool', 'ChannelPool')
 
@@ -819,7 +817,7 @@ class Connection:
         return exchange_type in self.transport.implements.exchange_type
 
     def __repr__(self):
-        return '<Connection: {} at {:#x}>'.format(self.as_uri(), id(self))
+        return f'<Connection: {self.as_uri()} at {id(self):#x}>'
 
     def __copy__(self):
         return self.clone()
@@ -972,7 +970,7 @@ class Connection:
         return self.transport.implements.asynchronous
 
 
-BrokerConnection = Connection  # noqa: E305
+BrokerConnection = Connection
 
 
 class ConnectionPool(Resource):
diff --git a/kombu/exceptions.py b/kombu/exceptions.py
index bc7a773c..f2501437 100644
--- a/kombu/exceptions.py
+++ b/kombu/exceptions.py
@@ -1,6 +1,6 @@
 """Exceptions."""
 
-from socket import timeout as TimeoutError  # noqa
+from socket import timeout as TimeoutError
 
 from amqp import ChannelError, ConnectionError, ResourceError
 
diff --git a/kombu/log.py b/kombu/log.py
index dff494aa..a29aadaa 100644
--- a/kombu/log.py
+++ b/kombu/log.py
@@ -4,7 +4,6 @@ import logging
 import numbers
 import os
 import sys
-
 from logging.handlers import WatchedFileHandler
 
 from .utils.encoding import safe_repr, safe_str
diff --git a/kombu/matcher.py b/kombu/matcher.py
index 63787ea9..7dcab8cd 100644
--- a/kombu/matcher.py
+++ b/kombu/matcher.py
@@ -1,7 +1,7 @@
 """Pattern matching registry."""
 
-from re import match as rematch
 from fnmatch import fnmatch
+from re import match as rematch
 
 from .utils.compat import entrypoints
 from .utils.encoding import bytes_to_str
diff --git a/kombu/message.py b/kombu/message.py
index 8c23b780..a4d7e2d4 100644
--- a/kombu/message.py
+++ b/kombu/message.py
@@ -3,7 +3,7 @@
 import sys
 
 from .compression import decompress
-from .exceptions import reraise, MessageStateError
+from .exceptions import MessageStateError, reraise
 from .serialization import loads
 from .utils.functional import dictfilter
 
diff --git a/kombu/messaging.py b/kombu/messaging.py
index e762c537..0bed52c5 100644
--- a/kombu/messaging.py
+++ b/kombu/messaging.py
@@ -4,7 +4,7 @@ from itertools import count
 
 from .common import maybe_declare
 from .compression import compress
-from .connection import maybe_channel, is_connection
+from .connection import is_connection, maybe_channel
 from .entity import Exchange, Queue, maybe_delivery_mode
 from .exceptions import ContentDisallowed
 from .serialization import dumps, prepare_accept_content
@@ -626,7 +626,7 @@ class Consumer:
             return on_m(message) if on_m else self.receive(decoded, message)
 
     def __repr__(self):
-        return '<{name}: {0.queues}>'.format(self, name=type(self).__name__)
+        return f'<{type(self).__name__}: {self.queues}>'
 
     @property
     def connection(self):
diff --git a/kombu/mixins.py b/kombu/mixins.py
index 29a1d545..b87e4b92 100644
--- a/kombu/mixins.py
+++ b/kombu/mixins.py
@@ -1,15 +1,14 @@
 """Mixins."""
 
 import socket
-
 from contextlib import contextmanager
 from functools import partial
 from itertools import count
 from time import sleep
 
 from .common import ignore_errors
-from .messaging import Consumer, Producer
 from .log import get_logger
+from .messaging import Consumer, Producer
 from .utils.compat import nested
 from .utils.encoding import safe_repr
 from .utils.limits import TokenBucket
diff --git a/kombu/pidbox.py b/kombu/pidbox.py
index c8179a53..da10d1ae 100644
--- a/kombu/pidbox.py
+++ b/kombu/pidbox.py
@@ -2,7 +2,6 @@
 
 import socket
 import warnings
-
 from collections import defaultdict, deque
 from contextlib import contextmanager
 from copy import copy
@@ -10,15 +9,15 @@ from itertools import count
 from threading import local
 from time import time
 
-from . import Exchange, Queue, Consumer, Producer
+from . import Consumer, Exchange, Producer, Queue
 from .clocks import LamportClock
 from .common import maybe_declare, oid_from
 from .exceptions import InconsistencyError
 from .log import get_logger
+from .matcher import match
 from .utils.functional import maybe_evaluate, reprcall
 from .utils.objects import cached_property
 from .utils.uuid import uuid
-from .matcher import match
 
 REPLY_QUEUE_EXPIRES = 10
 
diff --git a/kombu/pools.py b/kombu/pools.py
index 065a6ebb..373bc06c 100644
--- a/kombu/pools.py
+++ b/kombu/pools.py
@@ -1,7 +1,6 @@
 """Public resource pools."""
 
 import os
-
 from itertools import chain
 
 from .connection import Resource
@@ -107,7 +106,7 @@ class Connections(PoolGroup):
         return connection.Pool(limit=limit)
 
 
-connections = register_group(Connections(limit=use_global_limit))  # noqa: E305
+connections = register_group(Connections(limit=use_global_limit))
 
 
 class Producers(PoolGroup):
@@ -117,11 +116,11 @@ class Producers(PoolGroup):
         return ProducerPool(connections[connection], limit=limit)
 
 
-producers = register_group(Producers(limit=use_global_limit))  # noqa: E305
+producers = register_group(Producers(limit=use_global_limit))
 
 
 def _all_pools():
-    return chain(*[(g.values() if g else iter([])) for g in _groups])
+    return chain(*((g.values() if g else iter([])) for g in _groups))
 
 
 def get_limit():
diff --git a/kombu/resource.py b/kombu/resource.py
index 3b836c80..e3617dc4 100644
--- a/kombu/resource.py
+++ b/kombu/resource.py
@@ -1,8 +1,9 @@
 """Generic resource pool implementation."""
 
-from collections import deque
 import os
-from queue import Empty, LifoQueue as _LifoQueue
+from collections import deque
+from queue import Empty
+from queue import LifoQueue as _LifoQueue
 
 from . import exceptions
 from .utils.compat import register_after_fork
@@ -215,7 +216,7 @@ class Resource:
 
         _next_resource_id = 0
 
-        def acquire(self, *args, **kwargs):  # noqa
+        def acquire(self, *args, **kwargs):
             import traceback
             id = self._next_resource_id = self._next_resource_id + 1
             print(f'+{id} ACQUIRE {self.__class__.__name__}')
@@ -227,7 +228,7 @@ class Resource:
             r.acquired_by.append(traceback.format_stack())
             return r
 
-        def release(self, resource):  # noqa
+        def release(self, resource):
             id = resource._resource_id
             print(f'+{id} RELEASE {self.__class__.__name__}')
             r = self._orig_release(resource)
diff --git a/kombu/serialization.py b/kombu/serialization.py
index 86621df7..58c28717 100644
--- a/kombu/serialization.py
+++ b/kombu/serialization.py
@@ -4,15 +4,12 @@ import codecs
 import os
 import pickle
 import sys
-
 from collections import namedtuple
 from contextlib import contextmanager
 from io import BytesIO
 
-from .exceptions import (
-    reraise, ContentDisallowed, DecodeError,
-    EncodeError, SerializerNotInstalled
-)
+from .exceptions import (ContentDisallowed, DecodeError, EncodeError,
+                         SerializerNotInstalled, reraise)
 from .utils.compat import entrypoints
 from .utils.encoding import bytes_to_str, str_to_bytes
 
diff --git a/kombu/simple.py b/kombu/simple.py
index bab49881..eee037be 100644
--- a/kombu/simple.py
+++ b/kombu/simple.py
@@ -1,13 +1,11 @@
 """Simple messaging interface."""
 
 import socket
-
 from collections import deque
 from queue import Empty
 from time import monotonic
 
-from . import entity
-from . import messaging
+from . import entity, messaging
 from .connection import maybe_channel
 
 __all__ = ('SimpleQueue', 'SimpleBuffer')
diff --git a/kombu/transport/SLMQ.py b/kombu/transport/SLMQ.py
index ab23f88c..750f67bd 100644
--- a/kombu/transport/SLMQ.py
+++ b/kombu/transport/SLMQ.py
@@ -18,13 +18,13 @@ Transport Options
  *Unreviewed*
 """
 
+import os
 import socket
 import string
-import os
 from queue import Empty
 
 from kombu.utils.encoding import bytes_to_str, safe_str
-from kombu.utils.json import loads, dumps
+from kombu.utils.json import dumps, loads
 from kombu.utils.objects import cached_property
 
 from . import virtual
@@ -33,7 +33,7 @@ try:
     from softlayer_messaging import get_client
     from softlayer_messaging.errors import ResponseError
 except ImportError:  # pragma: no cover
-    get_client = ResponseError = None  # noqa
+    get_client = ResponseError = None
 
 # dots are replaced by dash, all other punctuation replaced by underscore.
 CHARS_REPLACE_TABLE = {
diff --git a/kombu/transport/SQS.py b/kombu/transport/SQS.py
index f2061a68..4e055de7 100644
--- a/kombu/transport/SQS.py
+++ b/kombu/transport/SQS.py
@@ -128,7 +128,7 @@ from queue import Empty
 
 from botocore.client import Config
 from botocore.exceptions import ClientError
-from vine import transform, ensure_promise, promise
+from vine import ensure_promise, promise, transform
 
 from kombu.asynchronous import get_event_loop
 from kombu.asynchronous.aws.ext import boto3, exceptions
@@ -137,7 +137,7 @@ from kombu.asynchronous.aws.sqs.message import AsyncMessage
 from kombu.log import get_logger
 from kombu.utils import scheduling
 from kombu.utils.encoding import bytes_to_str, safe_str
-from kombu.utils.json import loads, dumps
+from kombu.utils.json import dumps, loads
 from kombu.utils.objects import cached_property
 
 from . import virtual
diff --git a/kombu/transport/azureservicebus.py b/kombu/transport/azureservicebus.py
index 8b30be0f..83237424 100644
--- a/kombu/transport/azureservicebus.py
+++ b/kombu/transport/azureservicebus.py
@@ -55,20 +55,20 @@ Transport Options
 
 import string
 from queue import Empty
-from typing import Dict, Any, Optional, Union, Set, Tuple
-
-from kombu.utils.encoding import bytes_to_str, safe_str
-from kombu.utils.json import loads, dumps
-from kombu.utils.objects import cached_property
+from typing import Any, Dict, Optional, Set, Tuple, Union
 
 import azure.core.exceptions
 import azure.servicebus.exceptions
 import isodate
-from azure.servicebus import (
-    ServiceBusClient, ServiceBusMessage, ServiceBusReceiver, ServiceBusSender,
-    ServiceBusReceiveMode)
+from azure.servicebus import (ServiceBusClient, ServiceBusMessage,
+                              ServiceBusReceiveMode, ServiceBusReceiver,
+                              ServiceBusSender)
 from azure.servicebus.management import ServiceBusAdministrationClient
 
+from kombu.utils.encoding import bytes_to_str, safe_str
+from kombu.utils.json import dumps, loads
+from kombu.utils.objects import cached_property
+
 from . import virtual
 
 # dots are replaced by dash, all other punctuation replaced by underscore.
@@ -438,7 +438,7 @@ class Transport(virtual.Transport):
     @classmethod
     def as_uri(cls, uri: str, include_password=False, mask='**') -> str:
         namespace, policy, sas_key = cls.parse_uri(uri)
-        return 'azureservicebus://{0}:{1}@{2}'.format(
+        return 'azureservicebus://{}:{}@{}'.format(
             policy,
             sas_key if include_password else mask,
             namespace
diff --git a/kombu/transport/azurestoragequeues.py b/kombu/transport/azurestoragequeues.py
index 76fde77c..e83a20d3 100644
--- a/kombu/transport/azurestoragequeues.py
+++ b/kombu/transport/azurestoragequeues.py
@@ -30,11 +30,11 @@ Transport Options
 * ``queue_name_prefix``
 """
 
-from queue import Empty
 import string
+from queue import Empty
 
 from kombu.utils.encoding import safe_str
-from kombu.utils.json import loads, dumps
+from kombu.utils.json import dumps, loads
 from kombu.utils.objects import cached_property
 
 from . import virtual
@@ -42,7 +42,7 @@ from . import virtual
 try:
     from azure.storage.queue import QueueService
 except ImportError:  # pragma: no cover
-    QueueService = None  # noqa
+    QueueService = None
 
 # Azure storage queues allow only alphanumeric and dashes
 # so, replace everything with a dash
diff --git a/kombu/transport/consul.py b/kombu/transport/consul.py
index 5bebd8e4..ea275c95 100644
--- a/kombu/transport/consul.py
+++ b/kombu/transport/consul.py
@@ -27,9 +27,8 @@ Connection string has the following format:
 
 """
 
-import uuid
 import socket
-
+import uuid
 from collections import defaultdict
 from contextlib import contextmanager
 from queue import Empty
@@ -37,7 +36,7 @@ from time import monotonic
 
 from kombu.exceptions import ChannelError
 from kombu.log import get_logger
-from kombu.utils.json import loads, dumps
+from kombu.utils.json import dumps, loads
 from kombu.utils.objects import cached_property
 
 from . import virtual
@@ -215,7 +214,7 @@ class Channel(virtual.Channel):
         only one node reads at the same time. This is for read consistency
         """
         with self._queue_lock(queue, raising=Empty):
-            key = '{}/msg/'.format(self._key_prefix(queue))
+            key = f'{self._key_prefix(queue)}/msg/'
             logger.debug('Fetching key %s with index %s', key, self.index)
             self.index, data = self.client.kv.get(
                 key=key, recurse=True,
@@ -241,14 +240,14 @@ class Channel(virtual.Channel):
     def _purge(self, queue):
         self._destroy_session(queue)
         return self.client.kv.delete(
-            key='{}/msg/'.format(self._key_prefix(queue)),
+            key=f'{self._key_prefix(queue)}/msg/',
             recurse=True,
         )
 
     def _size(self, queue):
         size = 0
         try:
-            key = '{}/msg/'.format(self._key_prefix(queue))
+            key = f'{self._key_prefix(queue)}/msg/'
             logger.debug('Fetching key recursively %s with index %s',
                          key, self.index)
             self.index, data = self.client.kv.get(
diff --git a/kombu/transport/etcd.py b/kombu/transport/etcd.py
index 5ff7b922..4d0b0364 100644
--- a/kombu/transport/etcd.py
+++ b/kombu/transport/etcd.py
@@ -26,14 +26,13 @@ Connection string has the following format:
 
 import os
 import socket
-
 from collections import defaultdict
 from contextlib import contextmanager
 from queue import Empty
 
 from kombu.exceptions import ChannelError
 from kombu.log import get_logger
-from kombu.utils.json import loads, dumps
+from kombu.utils.json import dumps, loads
 from kombu.utils.objects import cached_property
 
 from . import virtual
@@ -187,7 +186,7 @@ class Channel(virtual.Channel):
                 self.client.delete(key=item['key'])
                 return msg_content
             except (TypeError, IndexError, etcd.EtcdException) as error:
-                logger.debug('_get failed: {}:{}'.format(type(error), error))
+                logger.debug(f'_get failed: {type(error)}:{error}')
 
             raise Empty()
 
diff --git a/kombu/transport/filesystem.py b/kombu/transport/filesystem.py
index 5edaa237..8717ca78 100644
--- a/kombu/transport/filesystem.py
+++ b/kombu/transport/filesystem.py
@@ -90,17 +90,17 @@ Transport Options
 
 import os
 import shutil
+import tempfile
 import uuid
 from queue import Empty
-import tempfile
 from time import monotonic
 
-from . import virtual
 from kombu.exceptions import ChannelError
 from kombu.utils.encoding import bytes_to_str, str_to_bytes
-from kombu.utils.json import loads, dumps
+from kombu.utils.json import dumps, loads
 from kombu.utils.objects import cached_property
 
+from . import virtual
 
 VERSION = (1, 0, 0)
 __version__ = '.'.join(map(str, VERSION))
@@ -108,14 +108,14 @@ __version__ = '.'.join(map(str, VERSION))
 # needs win32all to work on Windows
 if os.name == 'nt':
 
+    import pywintypes
     import win32con
     import win32file
-    import pywintypes
 
     LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
     # 0 is the default
-    LOCK_SH = 0                                     # noqa
-    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY    # noqa
+    LOCK_SH = 0
+    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
     __overlapped = pywintypes.OVERLAPPED()
 
     def lock(file, flags):
@@ -131,13 +131,13 @@ if os.name == 'nt':
 elif os.name == 'posix':
 
     import fcntl
-    from fcntl import LOCK_EX, LOCK_SH, LOCK_NB     # noqa
+    from fcntl import LOCK_EX, LOCK_NB, LOCK_SH  # noqa
 
-    def lock(file, flags):  # noqa
+    def lock(file, flags):
         """Create file lock."""
         fcntl.flock(file.fileno(), flags)
 
-    def unlock(file):       # noqa
+    def unlock(file):
         """Remove file lock."""
         fcntl.flock(file.fileno(), fcntl.LOCK_UN)
 else:
diff --git a/kombu/transport/memory.py b/kombu/transport/memory.py
index 72023e9e..0a778294 100644
--- a/kombu/transport/memory.py
+++ b/kombu/transport/memory.py
@@ -22,11 +22,10 @@ Connection string is in the following format:
 
 """
 
+from collections import defaultdict
 from queue import Queue
 
-from . import base
-from . import virtual
-from collections import defaultdict
+from . import base, virtual
 
 
 class Channel(virtual.Channel):
diff --git a/kombu/transport/mongodb.py b/kombu/transport/mongodb.py
index d0e12e4a..db758c18 100644
--- a/kombu/transport/mongodb.py
+++ b/kombu/transport/mongodb.py
@@ -37,20 +37,18 @@ import datetime
 from queue import Empty
 
 import pymongo
-from pymongo import errors
-from pymongo import MongoClient, uri_parser
+from pymongo import MongoClient, errors, uri_parser
 from pymongo.cursor import CursorType
 
 from kombu.exceptions import VersionMismatch
 from kombu.utils.compat import _detect_environment
 from kombu.utils.encoding import bytes_to_str
-from kombu.utils.json import loads, dumps
+from kombu.utils.json import dumps, loads
 from kombu.utils.objects import cached_property
 
 from . import virtual
 from .base import to_rabbitmq_queue_arguments
 
-
 E_SERVER_VERSION = """\
 Kombu requires MongoDB version 1.3+ (server is {0})\
 """
diff --git a/kombu/transport/pyro.py b/kombu/transport/pyro.py
index 9e86319b..4bae532c 100644
--- a/kombu/transport/pyro.py
+++ b/kombu/transport/pyro.py
@@ -33,11 +33,12 @@ Transport Options
 
 
 import sys
-from queue import Queue, Empty
+from queue import Empty, Queue
 
 from kombu.exceptions import reraise
-from kombu.utils.objects import cached_property
 from kombu.log import get_logger
+from kombu.utils.objects import cached_property
+
 from . import virtual
 
 try:
@@ -45,7 +46,7 @@ try:
     from Pyro4.errors import NamingError
     from Pyro4.util import SerializerBase
 except ImportError:          # pragma: no cover
-    pyro = NamingError = SerializerBase = None  # noqa
+    pyro = NamingError = SerializerBase = None
 
 DEFAULT_PORT = 9090
 E_NAMESERVER = """\
diff --git a/kombu/transport/qpid.py b/kombu/transport/qpid.py
index cacd3489..b0f8df13 100644
--- a/kombu/transport/qpid.py
+++ b/kombu/transport/qpid.py
@@ -86,34 +86,33 @@ Celery, this can be accomplished by setting the
 *BROKER_TRANSPORT_OPTIONS* Celery option.
 """
 
-from collections import OrderedDict
 import os
 import select
 import socket
 import ssl
 import sys
 import uuid
+from collections import OrderedDict
+from gettext import gettext as _
 from queue import Empty
 from time import monotonic
 
-from gettext import gettext as _
-
 import amqp.protocol
 
 try:
     import fcntl
 except ImportError:
-    fcntl = None  # noqa
+    fcntl = None
 
 try:
     import qpidtoollibs
 except ImportError:  # pragma: no cover
-    qpidtoollibs = None     # noqa
+    qpidtoollibs = None
 
 try:
-    from qpid.messaging.exceptions import ConnectionError, NotFound
+    from qpid.messaging.exceptions import ConnectionError
     from qpid.messaging.exceptions import Empty as QpidEmpty
-    from qpid.messaging.exceptions import SessionClosed
+    from qpid.messaging.exceptions import NotFound, SessionClosed
 except ImportError:  # pragma: no cover
     ConnectionError = None
     NotFound = None
@@ -126,9 +125,8 @@ except ImportError:  # pragma: no cover
     qpid = None
 
 from kombu.log import get_logger
-from kombu.transport.virtual import Base64, Message
 from kombu.transport import base, virtual
-
+from kombu.transport.virtual import Base64, Message
 
 logger = get_logger(__name__)
 
diff --git a/kombu/transport/redis.py b/kombu/transport/redis.py
index 76150158..5b4e1bca 100644
--- a/kombu/transport/redis.py
+++ b/kombu/transport/redis.py
@@ -51,7 +51,6 @@ Transport Options
 
 import numbers
 import socket
-
 from bisect import bisect
 from collections import namedtuple
 from contextlib import contextmanager
@@ -63,25 +62,25 @@ from vine import promise
 from kombu.exceptions import InconsistencyError, VersionMismatch
 from kombu.log import get_logger
 from kombu.utils.compat import register_after_fork
-from kombu.utils.eventio import poll, READ, ERR
 from kombu.utils.encoding import bytes_to_str
-from kombu.utils.json import loads, dumps
+from kombu.utils.eventio import ERR, READ, poll
+from kombu.utils.functional import accepts_argument
+from kombu.utils.json import dumps, loads
 from kombu.utils.objects import cached_property
 from kombu.utils.scheduling import cycle_by_name
 from kombu.utils.url import _parse_url
-from kombu.utils.functional import accepts_argument
 
 from . import virtual
 
 try:
     import redis
 except ImportError:  # pragma: no cover
-    redis = None     # noqa
+    redis = None
 
 try:
     from redis import sentinel
 except ImportError:  # pragma: no cover
-    sentinel = None  # noqa
+    sentinel = None
 
 
 logger = get_logger('kombu.transport.redis')
@@ -121,6 +120,7 @@ Probably the key ({1!r}) has been removed from the Redis database.
 def get_redis_error_classes():
     """Return tuple of redis error classes."""
     from redis import exceptions
+
     # This exception suddenly changed name between redis-py versions
     if hasattr(exceptions, 'InvalidData'):
         DataError = exceptions.InvalidData
diff --git a/kombu/transport/sqlalchemy/__init__.py b/kombu/transport/sqlalchemy/__init__.py
index 6ae04d0d..c4ecc6c7 100644
--- a/kombu/transport/sqlalchemy/__init__.py
+++ b/kombu/transport/sqlalchemy/__init__.py
@@ -55,7 +55,7 @@ Moreover parameters of :func:`sqlalchemy.create_engine()` function can be passed
 
 
 import threading
-from json import loads, dumps
+from json import dumps, loads
 from queue import Empty
 
 from sqlalchemy import create_engine
@@ -65,9 +65,11 @@ from sqlalchemy.orm import sessionmaker
 from kombu.transport import virtual
 from kombu.utils import cached_property
 from kombu.utils.encoding import bytes_to_str
-from .models import (ModelBase, Queue as QueueBase, Message as MessageBase,
-                     class_registry, metadata)
 
+from .models import Message as MessageBase
+from .models import ModelBase
+from .models import Queue as QueueBase
+from .models import class_registry, metadata
 
 VERSION = (1, 1, 0)
 __version__ = '.'.join(map(str, VERSION))
diff --git a/kombu/transport/sqlalchemy/models.py b/kombu/transport/sqlalchemy/models.py
index 6ffa2e3e..45863852 100644
--- a/kombu/transport/sqlalchemy/models.py
+++ b/kombu/transport/sqlalchemy/models.py
@@ -2,8 +2,8 @@
 
 import datetime
 
-from sqlalchemy import (Column, Integer, String, Text, DateTime,
-                        Sequence, Boolean, ForeignKey, SmallInteger, Index)
+from sqlalchemy import (Boolean, Column, DateTime, ForeignKey, Index, Integer,
+                        Sequence, SmallInteger, String, Text)
 from sqlalchemy.orm import relation
 from sqlalchemy.schema import MetaData
 
diff --git a/kombu/transport/virtual/__init__.py b/kombu/transport/virtual/__init__.py
index 579b87bf..7ab11772 100644
--- a/kombu/transport/virtual/__init__.py
+++ b/kombu/transport/virtual/__init__.py
@@ -1,8 +1,6 @@
-from .base import (
-    Base64, NotEquivalentError, UndeliverableWarning, BrokerState,
-    QoS, Message, AbstractChannel, Channel, Management, Transport,
-    Empty, binding_key_t, queue_binding_t,
-)
+from .base import (AbstractChannel, Base64, BrokerState, Channel, Empty,
+                   Management, Message, NotEquivalentError, QoS, Transport,
+                   UndeliverableWarning, binding_key_t, queue_binding_t)
 
 __all__ = (
     'Base64', 'NotEquivalentError', 'UndeliverableWarning', 'BrokerState',
diff --git a/kombu/transport/virtual/base.py b/kombu/transport/virtual/base.py
index 46bcae7e..f054d82f 100644
--- a/kombu/transport/virtual/base.py
+++ b/kombu/transport/virtual/base.py
@@ -7,25 +7,23 @@ import base64
 import socket
 import sys
 import warnings
-
 from array import array
 from collections import OrderedDict, defaultdict, namedtuple
 from itertools import count
 from multiprocessing.util import Finalize
 from queue import Empty
-from time import sleep, monotonic
+from time import monotonic, sleep
 
 from amqp.protocol import queue_declare_ok_t
 
-from kombu.exceptions import ResourceError, ChannelError
+from kombu.exceptions import ChannelError, ResourceError
 from kombu.log import get_logger
-from kombu.utils.encoding import str_to_bytes, bytes_to_str
+from kombu.transport import base
 from kombu.utils.div import emergency_dump_state
+from kombu.utils.encoding import bytes_to_str, str_to_bytes
 from kombu.utils.scheduling import FairCycle
 from kombu.utils.uuid import uuid
 
-from kombu.transport import base
-
 from .exchange import STANDARD_EXCHANGE_TYPES
 
 ARRAY_TYPE_H = 'H'
diff --git a/kombu/transport/zookeeper.py b/kombu/transport/zookeeper.py
index bfb557fe..1a2ab63c 100644
--- a/kombu/transport/zookeeper.py
+++ b/kombu/transport/zookeeper.py
@@ -86,8 +86,8 @@ try:
         socket.error,
     )
 except ImportError:
-    kazoo = None  # noqa
-    KZ_CONNECTION_ERRORS = KZ_CHANNEL_ERRORS = ()  # noqa
+    kazoo = None
+    KZ_CONNECTION_ERRORS = KZ_CHANNEL_ERRORS = ()
 
 DEFAULT_PORT = 2181
 
diff --git a/kombu/utils/__init__.py b/kombu/utils/__init__.py
index 9f9413fe..304e2dfa 100644
--- a/kombu/utils/__init__.py
+++ b/kombu/utils/__init__.py
@@ -3,9 +3,8 @@
 from .collections import EqualityDict
 from .compat import fileno, maybe_fileno, nested, register_after_fork
 from .div import emergency_dump_state
-from .functional import (
-    fxrange, fxrangemax, maybe_list, reprcall, retry_over_time,
-)
+from .functional import (fxrange, fxrangemax, maybe_list, reprcall,
+                         retry_over_time)
 from .imports import symbol_by_name
 from .objects import cached_property
 from .uuid import uuid
diff --git a/kombu/utils/compat.py b/kombu/utils/compat.py
index e0a9e94d..ffc224c1 100644
--- a/kombu/utils/compat.py
+++ b/kombu/utils/compat.py
@@ -2,10 +2,8 @@
 
 import numbers
 import sys
-
-from functools import wraps
-
 from contextlib import contextmanager
+from functools import wraps
 
 try:
     from importlib import metadata as importlib_metadata
@@ -13,18 +11,19 @@ except ImportError:
     # TODO: Remove this when we drop support for Python 3.7
     import importlib_metadata
 
+from io import UnsupportedOperation
+
 from kombu.exceptions import reraise
 
-from io import UnsupportedOperation
 FILENO_ERRORS = (AttributeError, ValueError, UnsupportedOperation)
 
 try:
     from billiard.util import register_after_fork
 except ImportError:  # pragma: no cover
     try:
-        from multiprocessing.util import register_after_fork  # noqa
+        from multiprocessing.util import register_after_fork
     except ImportError:
-        register_after_fork = None  # noqa
+        register_after_fork = None
 
 
 _environment = None
@@ -44,9 +43,10 @@ def _detect_environment():
     # ## -eventlet-
     if 'eventlet' in sys.modules:
         try:
-            from eventlet.patcher import is_monkey_patched as is_eventlet
             import socket
 
+            from eventlet.patcher import is_monkey_patched as is_eventlet
+
             if is_eventlet(socket):
                 return 'eventlet'
         except ImportError:
@@ -55,9 +55,10 @@ def _detect_environment():
     # ## -gevent-
     if 'gevent' in sys.modules:
         try:
-            from gevent import socket as _gsocket
             import socket
 
+            from gevent import socket as _gsocket
+
             if socket.socket is _gsocket.socket:
                 return 'gevent'
         except ImportError:
diff --git a/kombu/utils/div.py b/kombu/utils/div.py
index aa33532e..45be7f94 100644
--- a/kombu/utils/div.py
+++ b/kombu/utils/div.py
@@ -1,9 +1,9 @@
 """Div. Utilities."""
 
-from .encoding import default_encode
-
 import sys
 
+from .encoding import default_encode
+
 
 def emergency_dump_state(state, open_file=open, dump=None, stderr=None):
     """Dump message state to stdout or file."""
@@ -15,14 +15,14 @@ def emergency_dump_state(state, open_file=open, dump=None, stderr=None):
         import pickle
         dump = pickle.dump
     persist = mktemp()
-    print(f'EMERGENCY DUMP STATE TO FILE -> {persist} <-',  # noqa
+    print(f'EMERGENCY DUMP STATE TO FILE -> {persist} <-',
           file=stderr)
     fh = open_file(persist, 'w')
     try:
         try:
             dump(state, fh, protocol=0)
         except Exception as exc:
-            print(  # noqa
+            print(
                 f'Cannot pickle state: {exc!r}. Fallback to pformat.',
                 file=stderr,
             )
diff --git a/kombu/utils/encoding.py b/kombu/utils/encoding.py
index 9fe975e2..5f58f0fa 100644
--- a/kombu/utils/encoding.py
+++ b/kombu/utils/encoding.py
@@ -32,7 +32,7 @@ if sys.platform.startswith('java'):  # pragma: no cover
         return 'utf-8'
 else:
 
-    def default_encoding(file=None):  # noqa
+    def default_encoding(file=None):
         """Get default encoding."""
         file = file or get_default_encoding_file()
         return getattr(file, 'encoding', None) or sys.getfilesystemencoding()
diff --git a/kombu/utils/eventio.py b/kombu/utils/eventio.py
index fa7533d4..48260a48 100644
--- a/kombu/utils/eventio.py
+++ b/kombu/utils/eventio.py
@@ -4,7 +4,6 @@ import errno
 import math
 import select as __select__
 import sys
-
 from numbers import Integral
 
 from . import fileno
diff --git a/kombu/utils/functional.py b/kombu/utils/functional.py
index 02ed6ffa..366a0b99 100644
--- a/kombu/utils/functional.py
+++ b/kombu/utils/functional.py
@@ -1,11 +1,10 @@
 """Functional Utilities."""
 
-from collections import OrderedDict, UserDict
-from collections.abc import Iterable, Mapping
+import inspect
 import random
 import threading
-import inspect
-
+from collections import OrderedDict, UserDict
+from collections.abc import Iterable, Mapping
 from itertools import count, repeat
 from time import sleep, time
 
@@ -37,7 +36,7 @@ class ChannelPromise:
         try:
             return repr(self.__value__)
         except AttributeError:
-            return '<promise: 0x{:x}>'.format(id(self.__contract__))
+            return f'<promise: 0x{id(self.__contract__):x}>'
 
 
 class LRUCache(UserDict):
diff --git a/kombu/utils/json.py b/kombu/utils/json.py
index bdcb19e8..0cdf6376 100644
--- a/kombu/utils/json.py
+++ b/kombu/utils/json.py
@@ -8,7 +8,7 @@ import uuid
 try:
     from django.utils.functional import Promise as DjangoPromise
 except ImportError:  # pragma: no cover
-    class DjangoPromise:  # noqa
+    class DjangoPromise:
         """Dummy object."""
 
 try:
@@ -19,10 +19,10 @@ try:
         'namedtuple_as_object': False,
     }
 except ImportError:                 # pragma: no cover
-    import json                     # noqa
-    _json_extra_kwargs = {}           # noqa
+    import json
+    _json_extra_kwargs = {}
 
-    class _DecodeError(Exception):  # noqa
+    class _DecodeError(Exception):
         pass
 
 
diff --git a/kombu/utils/objects.py b/kombu/utils/objects.py
index fba8ed0b..7fef4a2f 100644
--- a/kombu/utils/objects.py
+++ b/kombu/utils/objects.py
@@ -3,7 +3,8 @@
 __all__ = ('cached_property',)
 
 try:
-    from functools import _NOT_FOUND, cached_property as _cached_property
+    from functools import _NOT_FOUND
+    from functools import cached_property as _cached_property
 except ImportError:
     # TODO: Remove this fallback once we drop support for Python < 3.8
     from cached_property import threaded_cached_property as _cached_property
diff --git a/kombu/utils/url.py b/kombu/utils/url.py
index 051bca70..de3a9139 100644
--- a/kombu/utils/url.py
+++ b/kombu/utils/url.py
@@ -3,7 +3,6 @@
 
 
 from collections.abc import Mapping
-
 from functools import partial
 from typing import NamedTuple
 from urllib.parse import parse_qsl, quote, unquote, urlparse
@@ -74,7 +73,7 @@ def url_to_parts(url):
     )
 
 
-_parse_url = url_to_parts  # noqa
+_parse_url = url_to_parts
 
 
 def as_url(scheme, host=None, port=None, user=None, password=None,
diff --git a/setup.cfg b/setup.cfg
index 72c76b22..0197a5f1 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -10,7 +10,7 @@ all_files = 1
 [flake8]
 # classes can be lowercase, arguments and variables can be uppercase
 # whenever it makes the code more readable.
-ignore = W504, N806, N802, N801, N803
+extend-ignore = W504, N806, N802, N801, N803
 
 [pep257]
 ignore = D102,D104,D203,D105,D213
diff --git a/setup.py b/setup.py
index 2e45a475..3a7ad0c9 100644
--- a/setup.py
+++ b/setup.py
@@ -2,16 +2,15 @@
 import os
 import re
 import sys
+from distutils.command.install import INSTALL_SCHEMES
 
 import setuptools
 import setuptools.command.test
 
-from distutils.command.install import INSTALL_SCHEMES
-
 try:
     from setuptools import setup
 except ImportError:
-    from distutils.core import setup  # noqa
+    from distutils.core import setup
 
 # -- Parse meta
 re_meta = re.compile(r'__(\w+?)__\s*=\s*(.*)')
@@ -70,16 +69,13 @@ py_version = sys.version_info
 is_pypy = hasattr(sys, 'pypy_version_info')
 
 
-def strip_comments(l):
-    return l.split('#', 1)[0].strip()
+def strip_comments(line):
+    return line.split('#', 1)[0].strip()
 
 
 def reqs(*f):
-    return [
-        r for r in (
-            strip_comments(l) for l in open(
-            os.path.join(os.getcwd(), 'requirements', *f)).readlines()
-        ) if r]
+    with open(os.path.join(os.getcwd(), "requirements", *f)) as reqs_file:
+        return [r for r in (strip_comments(line) for line in reqs_file) if r]
 
 
 def extras(*p):
diff --git a/t/integration/common.py b/t/integration/common.py
index a749bb60..5d3d6382 100644
--- a/t/integration/common.py
+++ b/t/integration/common.py
@@ -3,6 +3,7 @@ from contextlib import closing
 from time import sleep
 
 import pytest
+
 import kombu
 
 
diff --git a/t/integration/test_py_amqp.py b/t/integration/test_py_amqp.py
index da21be40..88ff0ac7 100644
--- a/t/integration/test_py_amqp.py
+++ b/t/integration/test_py_amqp.py
@@ -1,12 +1,11 @@
 import os
 
 import pytest
+
 import kombu
 
-from .common import (
-    BasicFunctionality, BaseExchangeTypes,
-    BaseTimeToLive, BasePriority, BaseFailover
-)
+from .common import (BaseExchangeTypes, BaseFailover, BasePriority,
+                     BaseTimeToLive, BasicFunctionality)
 
 
 def get_connection(hostname, port, vhost):
diff --git a/t/integration/test_redis.py b/t/integration/test_redis.py
index 459f0892..82eeceb2 100644
--- a/t/integration/test_redis.py
+++ b/t/integration/test_redis.py
@@ -1,12 +1,11 @@
 import os
+from time import sleep
 
 import pytest
+
 import kombu
-from time import sleep
 
-from .common import (
-    BasicFunctionality, BaseExchangeTypes, BasePriority
-)
+from .common import BaseExchangeTypes, BasePriority, BasicFunctionality
 
 
 def get_connection(
diff --git a/t/mocks.py b/t/mocks.py
index c515ed5d..d1bccf39 100644
--- a/t/mocks.py
+++ b/t/mocks.py
@@ -1,6 +1,6 @@
 from itertools import count
-
 from unittest.mock import Mock
+
 from case import ContextMock
 
 from kombu.transport import base
diff --git a/t/skip.py b/t/skip.py
index 487d80c8..d2c59caa 100644
--- a/t/skip.py
+++ b/t/skip.py
@@ -1,4 +1,5 @@
 import sys
+
 import pytest
 
 if_pypy = pytest.mark.skipif(
diff --git a/t/unit/asynchronous/aws/sqs/test_connection.py b/t/unit/asynchronous/aws/sqs/test_connection.py
index 7623a6d1..c3dd184b 100644
--- a/t/unit/asynchronous/aws/sqs/test_connection.py
+++ b/t/unit/asynchronous/aws/sqs/test_connection.py
@@ -1,13 +1,10 @@
-from unittest.mock import Mock, MagicMock
+from unittest.mock import MagicMock, Mock
 
-from kombu.asynchronous.aws.sqs.connection import (
-    AsyncSQSConnection
-)
 from kombu.asynchronous.aws.ext import boto3
+from kombu.asynchronous.aws.sqs.connection import AsyncSQSConnection
 from kombu.asynchronous.aws.sqs.message import AsyncMessage
 from kombu.asynchronous.aws.sqs.queue import AsyncQueue
 from kombu.utils.uuid import uuid
-
 from t.mocks import PromiseMock
 
 from ..case import AWSCase
diff --git a/t/unit/asynchronous/aws/sqs/test_queue.py b/t/unit/asynchronous/aws/sqs/test_queue.py
index e4ad1c6a..56812831 100644
--- a/t/unit/asynchronous/aws/sqs/test_queue.py
+++ b/t/unit/asynchronous/aws/sqs/test_queue.py
@@ -1,10 +1,9 @@
-import pytest
-
 from unittest.mock import Mock
 
+import pytest
+
 from kombu.asynchronous.aws.sqs.message import AsyncMessage
 from kombu.asynchronous.aws.sqs.queue import AsyncQueue
-
 from t.mocks import PromiseMock
 
 from ..case import AWSCase
diff --git a/t/unit/asynchronous/aws/test_connection.py b/t/unit/asynchronous/aws/test_connection.py
index 78cbe522..68e3c746 100644
--- a/t/unit/asynchronous/aws/test_connection.py
+++ b/t/unit/asynchronous/aws/test_connection.py
@@ -1,31 +1,25 @@
+from contextlib import contextmanager
 from io import StringIO
+from unittest.mock import Mock
 
 import pytest
-
-from contextlib import contextmanager
-
-from unittest.mock import Mock
 from vine.abstract import Thenable
 
-from kombu.exceptions import HttpError
-
 from kombu.asynchronous import http
-from kombu.asynchronous.aws.connection import (
-    AsyncHTTPSConnection,
-    AsyncHTTPResponse,
-    AsyncConnection,
-    AsyncAWSQueryConnection,
-)
+from kombu.asynchronous.aws.connection import (AsyncAWSQueryConnection,
+                                               AsyncConnection,
+                                               AsyncHTTPResponse,
+                                               AsyncHTTPSConnection)
 from kombu.asynchronous.aws.ext import boto3
+from kombu.exceptions import HttpError
+from t.mocks import PromiseMock
 
 from .case import AWSCase
 
-from t.mocks import PromiseMock
-
 try:
-    from urllib.parse import urlparse, parse_qs
+    from urllib.parse import parse_qs, urlparse
 except ImportError:
-    from urlparse import urlparse, parse_qs  # noqa
+    from urlparse import parse_qs, urlparse
 
 # Not currently working
 VALIDATES_CERT = False
diff --git a/t/unit/asynchronous/http/test_curl.py b/t/unit/asynchronous/http/test_curl.py
index 7c62808a..db8f5f91 100644
--- a/t/unit/asynchronous/http/test_curl.py
+++ b/t/unit/asynchronous/http/test_curl.py
@@ -1,10 +1,9 @@
-import pytest
-
 from unittest.mock import Mock, call, patch
 
-from kombu.asynchronous.http.curl import READ, WRITE, CurlClient
+import pytest
 
 import t.skip
+from kombu.asynchronous.http.curl import READ, WRITE, CurlClient
 
 pytest.importorskip('pycurl')
 
diff --git a/t/unit/asynchronous/http/test_http.py b/t/unit/asynchronous/http/test_http.py
index 110433fc..6e6abdcb 100644
--- a/t/unit/asynchronous/http/test_http.py
+++ b/t/unit/asynchronous/http/test_http.py
@@ -1,17 +1,14 @@
-import pytest
-
 from io import BytesIO
+from unittest.mock import Mock
 
+import pytest
 from vine import promise
 
-from unittest.mock import Mock
-
+import t.skip
 from kombu.asynchronous import http
 from kombu.asynchronous.http.base import BaseClient, normalize_header
 from kombu.exceptions import HttpError
-
 from t.mocks import PromiseMock
-import t.skip
 
 
 class test_Headers:
diff --git a/t/unit/asynchronous/test_hub.py b/t/unit/asynchronous/test_hub.py
index 31f21124..eae25357 100644
--- a/t/unit/asynchronous/test_hub.py
+++ b/t/unit/asynchronous/test_hub.py
@@ -1,16 +1,14 @@
 import errno
-import pytest
-
 from unittest.mock import Mock, call, patch
+
+import pytest
 from vine import promise
 
+from kombu.asynchronous import ERR, READ, WRITE, Hub
 from kombu.asynchronous import hub as _hub
-from kombu.asynchronous import Hub, READ, WRITE, ERR
-from kombu.asynchronous.debug import callback_for, repr_flag, _rcb
-from kombu.asynchronous.hub import (
-    Stop, get_event_loop, set_event_loop,
-    _raise_stop_error, _dummy_context
-)
+from kombu.asynchronous.debug import _rcb, callback_for, repr_flag
+from kombu.asynchronous.hub import (Stop, _dummy_context, _raise_stop_error,
+                                    get_event_loop, set_event_loop)
 from kombu.asynchronous.semaphore import DummyLock, LaxBoundedSemaphore
 
 
diff --git a/t/unit/asynchronous/test_timer.py b/t/unit/asynchronous/test_timer.py
index a521d368..20411784 100644
--- a/t/unit/asynchronous/test_timer.py
+++ b/t/unit/asynchronous/test_timer.py
@@ -1,9 +1,8 @@
-import pytest
-
 from datetime import datetime
-
 from unittest.mock import Mock, patch
 
+import pytest
+
 from kombu.asynchronous.timer import Entry, Timer, to_timestamp
 
 
diff --git a/t/unit/conftest.py b/t/unit/conftest.py
index 638fa9aa..d9cc0244 100644
--- a/t/unit/conftest.py
+++ b/t/unit/conftest.py
@@ -1,8 +1,9 @@
 import atexit
 import os
-import pytest
 import sys
 
+import pytest
+
 from kombu.exceptions import VersionMismatch
 
 
diff --git a/t/unit/test_clocks.py b/t/unit/test_clocks.py
index c8d52bec..b4392440 100644
--- a/t/unit/test_clocks.py
+++ b/t/unit/test_clocks.py
@@ -1,8 +1,6 @@
 import pickle
-
 from heapq import heappush
 from time import time
-
 from unittest.mock import Mock
 
 from kombu.clocks import LamportClock, timetuple
diff --git a/t/unit/test_common.py b/t/unit/test_common.py
index 4f560b67..33e2571f 100644
--- a/t/unit/test_common.py
+++ b/t/unit/test_common.py
@@ -1,18 +1,14 @@
-import pytest
 import socket
+from unittest.mock import Mock, patch
 
+import pytest
 from amqp import RecoverableConnectionError
-from unittest.mock import Mock, patch
 from case import ContextMock
 
 from kombu import common
-from kombu.common import (
-    Broadcast, maybe_declare,
-    send_reply, collect_replies,
-    declaration_cached, ignore_errors,
-    QoS, PREFETCH_COUNT_MAX, generate_oid
-)
-
+from kombu.common import (PREFETCH_COUNT_MAX, Broadcast, QoS, collect_replies,
+                          declaration_cached, generate_oid, ignore_errors,
+                          maybe_declare, send_reply)
 from t.mocks import MockPool
 
 
diff --git a/t/unit/test_compat.py b/t/unit/test_compat.py
index a4ff98b2..d75ce5df 100644
--- a/t/unit/test_compat.py
+++ b/t/unit/test_compat.py
@@ -1,11 +1,9 @@
-import pytest
-
 from unittest.mock import Mock, patch
 
-from kombu import Connection, Exchange, Queue
-from kombu import compat
+import pytest
 
-from t.mocks import Transport, Channel
+from kombu import Connection, Exchange, Queue, compat
+from t.mocks import Channel, Transport
 
 
 class test_misc:
diff --git a/t/unit/test_connection.py b/t/unit/test_connection.py
index 32c46dd2..0b184d3b 100644
--- a/t/unit/test_connection.py
+++ b/t/unit/test_connection.py
@@ -1,16 +1,14 @@
 import pickle
-import pytest
 import socket
-
 from copy import copy, deepcopy
-
 from unittest.mock import Mock, patch
 
+import pytest
+
 from kombu import Connection, Consumer, Producer, parse_url
 from kombu.connection import Resource
 from kombu.exceptions import OperationalError
 from kombu.utils.functional import lazy
-
 from t.mocks import Transport
 
 
diff --git a/t/unit/test_entity.py b/t/unit/test_entity.py
index 3ba36bef..52c42b2b 100644
--- a/t/unit/test_entity.py
+++ b/t/unit/test_entity.py
@@ -1,13 +1,12 @@
 import pickle
-import pytest
-
 from unittest.mock import Mock, call
 
+import pytest
+
 from kombu import Connection, Exchange, Producer, Queue, binding
 from kombu.abstract import MaybeChannelBound
 from kombu.exceptions import NotBoundError
 from kombu.serialization import registry
-
 from t.mocks import Transport
 
 
diff --git a/t/unit/test_log.py b/t/unit/test_log.py
index bd3cb636..4a8cd94c 100644
--- a/t/unit/test_log.py
+++ b/t/unit/test_log.py
@@ -1,16 +1,9 @@
 import logging
 import sys
-
 from unittest.mock import ANY, Mock, patch
 
-from kombu.log import (
-    get_logger,
-    get_loglevel,
-    safeify_format,
-    Log,
-    LogMixin,
-    setup_logging,
-)
+from kombu.log import (Log, LogMixin, get_logger, get_loglevel, safeify_format,
+                       setup_logging)
 
 
 class test_get_logger:
diff --git a/t/unit/test_matcher.py b/t/unit/test_matcher.py
index 0428ee15..2100fa74 100644
--- a/t/unit/test_matcher.py
+++ b/t/unit/test_matcher.py
@@ -1,10 +1,8 @@
-from kombu.matcher import (
-    match, register, registry, unregister, fnmatch, rematch,
-    MatcherNotInstalled
-)
-
 import pytest
 
+from kombu.matcher import (MatcherNotInstalled, fnmatch, match, register,
+                           registry, rematch, unregister)
+
 
 class test_Matcher:
 
diff --git a/t/unit/test_message.py b/t/unit/test_message.py
index a0be3a46..5b0833dd 100644
--- a/t/unit/test_message.py
+++ b/t/unit/test_message.py
@@ -1,8 +1,8 @@
-import pytest
 import sys
-
 from unittest.mock import Mock, patch
 
+import pytest
+
 from kombu.message import Message
 
 
diff --git a/t/unit/test_messaging.py b/t/unit/test_messaging.py
index dc673e07..f8ed437c 100644
--- a/t/unit/test_messaging.py
+++ b/t/unit/test_messaging.py
@@ -1,16 +1,14 @@
 import pickle
-import pytest
 import sys
-
 from collections import defaultdict
-
 from unittest.mock import Mock, patch
 
-from kombu import Connection, Consumer, Producer, Exchange, Queue
+import pytest
+
+from kombu import Connection, Consumer, Exchange, Producer, Queue
 from kombu.exceptions import MessageStateError
 from kombu.utils import json
 from kombu.utils.functional import ChannelPromise
-
 from t.mocks import Transport
 
 
diff --git a/t/unit/test_mixins.py b/t/unit/test_mixins.py
index 12647bf1..a86c3978 100644
--- a/t/unit/test_mixins.py
+++ b/t/unit/test_mixins.py
@@ -1,7 +1,7 @@
-import pytest
 import socket
-
 from unittest.mock import Mock, patch
+
+import pytest
 from case import ContextMock
 
 from kombu.mixins import ConsumerMixin
diff --git a/t/unit/test_pidbox.py b/t/unit/test_pidbox.py
index dc2467cb..7a1b9b1f 100644
--- a/t/unit/test_pidbox.py
+++ b/t/unit/test_pidbox.py
@@ -1,11 +1,10 @@
-import pytest
 import socket
 import warnings
-
 from unittest.mock import Mock, patch
 
-from kombu import Connection
-from kombu import pidbox
+import pytest
+
+from kombu import Connection, pidbox
 from kombu.exceptions import ContentDisallowed, InconsistencyError
 from kombu.utils.uuid import uuid
 
diff --git a/t/unit/test_pools.py b/t/unit/test_pools.py
index 2857914e..9f33f4b8 100644
--- a/t/unit/test_pools.py
+++ b/t/unit/test_pools.py
@@ -1,9 +1,8 @@
-import pytest
-
 from unittest.mock import Mock
 
-from kombu import Connection, Producer
-from kombu import pools
+import pytest
+
+from kombu import Connection, Producer, pools
 from kombu.connection import ConnectionPool
 from kombu.utils.collections import eqhash
 
diff --git a/t/unit/test_serialization.py b/t/unit/test_serialization.py
index fe5ea625..29c9d809 100644
--- a/t/unit/test_serialization.py
+++ b/t/unit/test_serialization.py
@@ -1,23 +1,21 @@
 #!/usr/bin/python
 
-import pytest
-
 from base64 import b64decode
-
 from unittest.mock import call, patch
-from case import mock
 
-from kombu.exceptions import ContentDisallowed, EncodeError, DecodeError
-from kombu.serialization import (
-    registry, register, SerializerNotInstalled,
-    raw_encode, register_yaml, register_msgpack,
-    dumps, loads, pickle, pickle_protocol,
-    unregister, register_pickle, enable_insecure_serializers,
-    disable_insecure_serializers, prepare_accept_content
-)
-from kombu.utils.encoding import str_to_bytes
+import pytest
+from case import mock
 
 import t.skip
+from kombu.exceptions import ContentDisallowed, DecodeError, EncodeError
+from kombu.serialization import (SerializerNotInstalled,
+                                 disable_insecure_serializers, dumps,
+                                 enable_insecure_serializers, loads, pickle,
+                                 pickle_protocol, prepare_accept_content,
+                                 raw_encode, register, register_msgpack,
+                                 register_pickle, register_yaml, registry,
+                                 unregister)
+from kombu.utils.encoding import str_to_bytes
 
 # For content_encoding tests
 unicode_string = 'abcdé\u8463'
diff --git a/t/unit/test_simple.py b/t/unit/test_simple.py
index c4badb03..a5cd899a 100644
--- a/t/unit/test_simple.py
+++ b/t/unit/test_simple.py
@@ -1,7 +1,7 @@
-import pytest
-
 from unittest.mock import Mock
 
+import pytest
+
 from kombu import Connection, Exchange, Queue
 from kombu.exceptions import ContentDisallowed
 
diff --git a/t/unit/transport/test_SQS.py b/t/unit/transport/test_SQS.py
index 5d958c8b..9a105837 100644
--- a/t/unit/transport/test_SQS.py
+++ b/t/unit/transport/test_SQS.py
@@ -6,22 +6,21 @@ slightly.
 """
 import base64
 import os
-from datetime import datetime, timedelta
-
-import pytest
 import random
 import string
+from datetime import datetime, timedelta
 from queue import Empty
-
 from unittest.mock import Mock, patch
 
-from kombu import messaging
-from kombu import Connection, Exchange, Queue
+import pytest
+
+from kombu import Connection, Exchange, Queue, messaging
 
 boto3 = pytest.importorskip('boto3')
 
-from kombu.transport import SQS                 # noqa
-from botocore.exceptions import ClientError     # noqa
+from botocore.exceptions import ClientError  # noqa
+
+from kombu.transport import SQS  # noqa
 
 SQS_Channel_sqs = SQS.Channel.sqs
 
@@ -63,7 +62,7 @@ class QueueMock:
         self.messages = []
 
     def __repr__(self):
-        return 'QueueMock: {} {} messages'.format(self.url, len(self.messages))
+        return f'QueueMock: {self.url} {len(self.messages)} messages'
 
 
 class SQSClientMock:
diff --git a/t/unit/transport/test_azureservicebus.py b/t/unit/transport/test_azureservicebus.py
index 47cc9fd5..97775d06 100644
--- a/t/unit/transport/test_azureservicebus.py
+++ b/t/unit/transport/test_azureservicebus.py
@@ -1,19 +1,20 @@
-import json
-import pytest
 import base64
+import json
 import random
+from collections import namedtuple
 from queue import Empty
+from unittest.mock import MagicMock, patch
 
-from unittest.mock import patch, MagicMock
-from collections import namedtuple
-from kombu import messaging
-from kombu import Connection, Exchange, Queue
+import pytest
+
+from kombu import Connection, Exchange, Queue, messaging
 
 pytest.importorskip('azure.servicebus')
-from kombu.transport import azureservicebus   # noqa 
-import azure.servicebus.exceptions   # noqa
-import azure.core.exceptions   # noqa
-from azure.servicebus import ServiceBusMessage, ServiceBusReceiveMode   # noqa
+import azure.core.exceptions  # noqa
+import azure.servicebus.exceptions  # noqa
+from azure.servicebus import ServiceBusMessage, ServiceBusReceiveMode  # noqa
+
+from kombu.transport import azureservicebus  # noqa
 
 
 class ASBQueue:
@@ -181,7 +182,7 @@ def test_invalid_peek_lock_seconds():
 
 @pytest.fixture
 def random_queue():
-    return 'azureservicebus_queue_{0}'.format(random.randint(1000, 9999))
+    return f'azureservicebus_queue_{random.randint(1000, 9999)}'
 
 
 @pytest.fixture
@@ -255,7 +256,7 @@ def test_empty_queue_get(mock_queue: MockQueue):
 
 def test_delete_empty_queue(mock_queue: MockQueue):
     chan = mock_queue.channel
-    queue_name = 'random_queue_{0}'.format(random.randint(1000, 9999))
+    queue_name = f'random_queue_{random.randint(1000, 9999)}'
 
     chan._new_queue(queue_name)
     assert queue_name in chan._queue_cache
diff --git a/t/unit/transport/test_base.py b/t/unit/transport/test_base.py
index e122b1e2..7df12c9e 100644
--- a/t/unit/transport/test_base.py
+++ b/t/unit/transport/test_base.py
@@ -1,12 +1,11 @@
-import pytest
-
 from unittest.mock import Mock
 
+import pytest
+
 from kombu import Connection, Consumer, Exchange, Producer, Queue
 from kombu.message import Message
-from kombu.transport.base import (
-    StdChannel, Transport, Management, to_rabbitmq_queue_arguments,
-)
+from kombu.transport.base import (Management, StdChannel, Transport,
+                                  to_rabbitmq_queue_arguments)
 
 
 @pytest.mark.parametrize('args,input,expected', [
diff --git a/t/unit/transport/test_consul.py b/t/unit/transport/test_consul.py
index 0ae02fa8..ce6c4fcb 100644
--- a/t/unit/transport/test_consul.py
+++ b/t/unit/transport/test_consul.py
@@ -1,9 +1,8 @@
-import pytest
-
 from queue import Empty
-
 from unittest.mock import Mock
 
+import pytest
+
 from kombu.transport.consul import Channel, Transport
 
 pytest.importorskip('consul')
diff --git a/t/unit/transport/test_etcd.py b/t/unit/transport/test_etcd.py
index fb4eeec5..6c75a033 100644
--- a/t/unit/transport/test_etcd.py
+++ b/t/unit/transport/test_etcd.py
@@ -1,9 +1,8 @@
-import pytest
-
 from queue import Empty
-
 from unittest.mock import Mock, patch
 
+import pytest
+
 from kombu.transport.etcd import Channel, Transport
 
 pytest.importorskip('etcd')
diff --git a/t/unit/transport/test_filesystem.py b/t/unit/transport/test_filesystem.py
index 0702ad3c..a8d1708b 100644
--- a/t/unit/transport/test_filesystem.py
+++ b/t/unit/transport/test_filesystem.py
@@ -1,9 +1,9 @@
 import tempfile
 
 import pytest
-import t.skip
 
-from kombu import Connection, Exchange, Queue, Consumer, Producer
+import t.skip
+from kombu import Connection, Consumer, Exchange, Producer, Queue
 
 
 @t.skip.if_win32
diff --git a/t/unit/transport/test_librabbitmq.py b/t/unit/transport/test_librabbitmq.py
index e409c76b..58ee7e1e 100644
--- a/t/unit/transport/test_librabbitmq.py
+++ b/t/unit/transport/test_librabbitmq.py
@@ -1,7 +1,7 @@
-import pytest
-
 from unittest.mock import Mock, patch
 
+import pytest
+
 pytest.importorskip('librabbitmq')
 
 from kombu.transport import librabbitmq  # noqa
diff --git a/t/unit/transport/test_memory.py b/t/unit/transport/test_memory.py
index 6db08827..2c1fe83f 100644
--- a/t/unit/transport/test_memory.py
+++ b/t/unit/transport/test_memory.py
@@ -1,7 +1,8 @@
-import pytest
 import socket
 
-from kombu import Connection, Exchange, Queue, Consumer, Producer
+import pytest
+
+from kombu import Connection, Consumer, Exchange, Producer, Queue
 
 
 class test_MemoryTransport:
diff --git a/t/unit/transport/test_mongodb.py b/t/unit/transport/test_mongodb.py
index eaba3769..39976988 100644
--- a/t/unit/transport/test_mongodb.py
+++ b/t/unit/transport/test_mongodb.py
@@ -1,17 +1,16 @@
 import datetime
-import pytest
-
 from queue import Empty
-
 from unittest.mock import MagicMock, call, patch
 
+import pytest
+
 from kombu import Connection
 
 pymongo = pytest.importorskip('pymongo')
 
 
 def _create_mock_connection(url='', **kwargs):
-    from kombu.transport import mongodb  # noqa
+    from kombu.transport import mongodb
 
     class _Channel(mongodb.Channel):
         # reset _fanout_queues for each instance
diff --git a/t/unit/transport/test_pyamqp.py b/t/unit/transport/test_pyamqp.py
index 3ca9a83f..c7243e8e 100644
--- a/t/unit/transport/test_pyamqp.py
+++ b/t/unit/transport/test_pyamqp.py
@@ -1,8 +1,7 @@
 import sys
-
 from itertools import count
-
 from unittest.mock import Mock, patch
+
 from case import mock
 
 from kombu import Connection
diff --git a/t/unit/transport/test_pyro.py b/t/unit/transport/test_pyro.py
index a7d27324..325f81ce 100644
--- a/t/unit/transport/test_pyro.py
+++ b/t/unit/transport/test_pyro.py
@@ -1,7 +1,8 @@
-import pytest
 import socket
 
-from kombu import Connection, Exchange, Queue, Consumer, Producer
+import pytest
+
+from kombu import Connection, Consumer, Exchange, Producer, Queue
 
 
 class test_PyroTransport:
diff --git a/t/unit/transport/test_qpid.py b/t/unit/transport/test_qpid.py
index dba2f514..351a929b 100644
--- a/t/unit/transport/test_qpid.py
+++ b/t/unit/transport/test_qpid.py
@@ -1,26 +1,22 @@
-import pytest
 import select
-import ssl
 import socket
+import ssl
 import sys
 import time
 import uuid
-from queue import Empty
-
 from collections import OrderedDict
-
 from collections.abc import Callable
-
 from itertools import count
-
+from queue import Empty
 from unittest.mock import Mock, call, patch
 
+import pytest
+
 from kombu.transport.qpid import (AuthenticationFailure, Channel, Connection,
                                   ConnectionError, Message, NotFound, QoS,
                                   Transport)
 from kombu.transport.virtual import Base64
 
-
 QPID_MODULE = 'kombu.transport.qpid'
 
 
diff --git a/t/unit/transport/test_redis.py b/t/unit/transport/test_redis.py
index 5b1ed971..52ea7f81 100644
--- a/t/unit/transport/test_redis.py
+++ b/t/unit/transport/test_redis.py
@@ -1,15 +1,15 @@
-import pytest
-
 import socket
 import types
-
 from collections import defaultdict
 from itertools import count
-from queue import Empty, Queue as _Queue
+from queue import Empty
+from queue import Queue as _Queue
 from unittest.mock import ANY, Mock, call, patch
+
+import pytest
 from case import ContextMock, mock
 
-from kombu import Connection, Exchange, Queue, Consumer, Producer
+from kombu import Connection, Consumer, Exchange, Producer, Queue
 from kombu.exceptions import InconsistencyError, VersionMismatch
 from kombu.transport import virtual
 from kombu.utils import eventio  # patch poll
@@ -314,6 +314,7 @@ class test_Channel:
 
     def test_get_redis_ConnectionError(self):
         from redis.exceptions import ConnectionError
+
         from kombu.transport.redis import get_redis_ConnectionError
         connection_error = get_redis_ConnectionError()
         assert connection_error == ConnectionError
diff --git a/t/unit/transport/test_sqlalchemy.py b/t/unit/transport/test_sqlalchemy.py
index c988cf33..5ddca5ac 100644
--- a/t/unit/transport/test_sqlalchemy.py
+++ b/t/unit/transport/test_sqlalchemy.py
@@ -1,8 +1,8 @@
-import pytest
 from unittest.mock import patch
 
-from kombu import Connection
+import pytest
 
+from kombu import Connection
 
 pytest.importorskip('sqlalchemy')
 
diff --git a/t/unit/transport/test_zookeeper.py b/t/unit/transport/test_zookeeper.py
index 6650f03c..21fcac42 100644
--- a/t/unit/transport/test_zookeeper.py
+++ b/t/unit/transport/test_zookeeper.py
@@ -1,4 +1,5 @@
 import pytest
+
 from kombu import Connection
 from kombu.transport import zookeeper
 
diff --git a/t/unit/transport/virtual/test_base.py b/t/unit/transport/virtual/test_base.py
index 08ae0a84..1a079a36 100644
--- a/t/unit/transport/virtual/test_base.py
+++ b/t/unit/transport/virtual/test_base.py
@@ -1,14 +1,14 @@
 import io
-import pytest
-import warnings
 import socket
+import warnings
 from time import monotonic
-
 from unittest.mock import MagicMock, Mock, patch
 
+import pytest
+
 from kombu import Connection
 from kombu.compression import compress
-from kombu.exceptions import ResourceError, ChannelError
+from kombu.exceptions import ChannelError, ResourceError
 from kombu.transport import virtual
 from kombu.utils.uuid import uuid
 
diff --git a/t/unit/transport/virtual/test_exchange.py b/t/unit/transport/virtual/test_exchange.py
index 8ae2bb5a..ac0a8b68 100644
--- a/t/unit/transport/virtual/test_exchange.py
+++ b/t/unit/transport/virtual/test_exchange.py
@@ -1,10 +1,9 @@
-import pytest
-
 from unittest.mock import Mock
 
+import pytest
+
 from kombu import Connection
 from kombu.transport.virtual import exchange
-
 from t.mocks import Transport
 
 
diff --git a/t/unit/utils/test_amq_manager.py b/t/unit/utils/test_amq_manager.py
index 663e922e..aa3d7574 100644
--- a/t/unit/utils/test_amq_manager.py
+++ b/t/unit/utils/test_amq_manager.py
@@ -1,6 +1,6 @@
-import pytest
-
 from unittest.mock import patch
+
+import pytest
 from case import mock
 
 from kombu import Connection
diff --git a/t/unit/utils/test_compat.py b/t/unit/utils/test_compat.py
index ce0c0cc8..a0bf18b0 100644
--- a/t/unit/utils/test_compat.py
+++ b/t/unit/utils/test_compat.py
@@ -1,8 +1,8 @@
 import socket
 import sys
 import types
-
 from unittest.mock import Mock, patch
+
 from case import mock
 
 from kombu.utils import compat
diff --git a/t/unit/utils/test_debug.py b/t/unit/utils/test_debug.py
index ca3cad8c..020bc849 100644
--- a/t/unit/utils/test_debug.py
+++ b/t/unit/utils/test_debug.py
@@ -1,5 +1,4 @@
 import logging
-
 from unittest.mock import Mock, patch
 
 from kombu.utils.debug import Logwrapped, setup_logging
diff --git a/t/unit/utils/test_div.py b/t/unit/utils/test_div.py
index 2a63d140..b29b6119 100644
--- a/t/unit/utils/test_div.py
+++ b/t/unit/utils/test_div.py
@@ -1,6 +1,5 @@
 import pickle
-
-from io import StringIO, BytesIO
+from io import BytesIO, StringIO
 
 from kombu.utils.div import emergency_dump_state
 
diff --git a/t/unit/utils/test_encoding.py b/t/unit/utils/test_encoding.py
index cf50c746..26e3ef36 100644
--- a/t/unit/utils/test_encoding.py
+++ b/t/unit/utils/test_encoding.py
@@ -1,13 +1,9 @@
 import sys
-
 from contextlib import contextmanager
-
 from unittest.mock import patch
 
-from kombu.utils.encoding import (
-    get_default_encoding_file, safe_str,
-    set_default_encoding_file, default_encoding,
-)
+from kombu.utils.encoding import (default_encoding, get_default_encoding_file,
+                                  safe_str, set_default_encoding_file)
 
 
 @contextmanager
diff --git a/t/unit/utils/test_functional.py b/t/unit/utils/test_functional.py
index 162c16d9..42c53caf 100644
--- a/t/unit/utils/test_functional.py
+++ b/t/unit/utils/test_functional.py
@@ -1,18 +1,15 @@
 import pickle
-
-import pytest
-
 from itertools import count
-
 from unittest.mock import Mock
+
+import pytest
 from case import mock
 
 from kombu.utils import functional as utils
-from kombu.utils.functional import (
-    ChannelPromise, LRUCache, fxrange, fxrangemax, memoize, lazy,
-    maybe_evaluate, maybe_list, reprcall, reprkwargs, retry_over_time,
-    accepts_argument,
-)
+from kombu.utils.functional import (ChannelPromise, LRUCache, accepts_argument,
+                                    fxrange, fxrangemax, lazy, maybe_evaluate,
+                                    maybe_list, memoize, reprcall, reprkwargs,
+                                    retry_over_time)
 
 
 class test_ChannelPromise:
diff --git a/t/unit/utils/test_imports.py b/t/unit/utils/test_imports.py
index 5dc95b75..8a4873df 100644
--- a/t/unit/utils/test_imports.py
+++ b/t/unit/utils/test_imports.py
@@ -1,7 +1,7 @@
-import pytest
-
 from unittest.mock import Mock
 
+import pytest
+
 from kombu import Exchange
 from kombu.utils.imports import symbol_by_name
 
diff --git a/t/unit/utils/test_json.py b/t/unit/utils/test_json.py
index e3a8fa11..6af1c13b 100644
--- a/t/unit/utils/test_json.py
+++ b/t/unit/utils/test_json.py
@@ -1,12 +1,11 @@
-import pytest
-import pytz
-
 from collections import namedtuple
 from datetime import datetime
 from decimal import Decimal
+from unittest.mock import MagicMock, Mock
 from uuid import uuid4
 
-from unittest.mock import MagicMock, Mock
+import pytest
+import pytz
 
 from kombu.utils.encoding import str_to_bytes
 from kombu.utils.json import _DecodeError, dumps, loads
diff --git a/t/unit/utils/test_objects.py b/t/unit/utils/test_objects.py
index 330a7db5..93a88b4f 100644
--- a/t/unit/utils/test_objects.py
+++ b/t/unit/utils/test_objects.py
@@ -12,7 +12,7 @@ class test_cached_property:
             def foo(self):
                 return 42
 
-            @foo.deleter  # noqa
+            @foo.deleter
             def foo(self, value):
                 self.xx = value
 
@@ -32,7 +32,7 @@ class test_cached_property:
             def foo(self):
                 return 42
 
-            @foo.setter  # noqa
+            @foo.setter
             def foo(self, value):
                 self.xx = 10
 
diff --git a/t/unit/utils/test_scheduling.py b/t/unit/utils/test_scheduling.py
index 43bb7014..44cf01a2 100644
--- a/t/unit/utils/test_scheduling.py
+++ b/t/unit/utils/test_scheduling.py
@@ -1,7 +1,7 @@
-import pytest
-
 from unittest.mock import Mock
 
+import pytest
+
 from kombu.utils.scheduling import FairCycle, cycle_by_name
 
 
diff --git a/t/unit/utils/test_url.py b/t/unit/utils/test_url.py
index 18588bca..71ea0f9b 100644
--- a/t/unit/utils/test_url.py
+++ b/t/unit/utils/test_url.py
@@ -8,8 +8,8 @@ import ssl
 import pytest
 
 import kombu.utils.url
-from kombu.utils.url import as_url, parse_url, maybe_sanitize_url
-from kombu.utils.url import parse_ssl_cert_reqs
+from kombu.utils.url import (as_url, maybe_sanitize_url, parse_ssl_cert_reqs,
+                             parse_url)
 
 
 def test_parse_url():