Bump pyupgrade target to 3.10+

... according to the versions currently supported.

Change-Id: I439b47e18884e44f11ca291df5e5256d907fa0fa
Signed-off-by: Takashi Kajinami <kajinamit@oss.nttdata.com>

.pre-commit-config.yaml

@@ -26,4 +26,4 @@ repos:
     rev: v3.20.0
     hooks:
       - id: pyupgrade
-        args: [--py3-only]
+        args: [--py310-plus]

oslo_messaging/_drivers/amqpdriver.py

@@ -124,7 +124,7 @@ class MessageOperationsHandler:
     """
 
     def __init__(self, name):
-        self.name = "{} ({})".format(name, hex(id(self)))
+        self.name = f"{name} ({hex(id(self))})"
         self._tasks = queue.Queue()
 
         self._shutdown = eventletutils.Event()
@@ -777,7 +777,7 @@ class AMQPDriverBase(base.BaseDriver):
                     topic = target.topic
                     exchange = self._get_exchange(target)
                     if target.server:
-                        topic = '{}.{}'.format(target.topic, target.server)
+                        topic = f'{target.topic}.{target.server}'
                     LOG.debug(log_msg + "exchange '%(exchange)s'"
                               " topic '%(topic)s'", {'exchange': exchange,
                                                      'topic': topic})
@@ -830,7 +830,7 @@ class AMQPDriverBase(base.BaseDriver):
         for target, priority in targets_and_priorities:
             conn.declare_topic_consumer(
                 exchange_name=self._get_exchange(target),
-                topic='{}.{}'.format(target.topic, priority),
+                topic=f'{target.topic}.{priority}',
                 callback=listener, queue_name=pool)
         return base.PollStyleListenerAdapter(listener, batch_size,
                                              batch_timeout)

oslo_messaging/_drivers/common.py

@@ -235,7 +235,7 @@ def deserialize_remote_exception(data, allowed_remote_exmods):
     str_override = lambda self: message
     new_ex_type = type(ex_type.__name__ + _REMOTE_POSTFIX, (ex_type,),
                        {'__str__': str_override, '__unicode__': str_override})
-    new_ex_type.__module__ = '{}{}'.format(module, _REMOTE_POSTFIX)
+    new_ex_type.__module__ = f'{module}{_REMOTE_POSTFIX}'
     try:
         # NOTE(ameade): Dynamically create a new exception type and swap it in
         # as the new type for the exception. This only works on user defined

oslo_messaging/_drivers/impl_fake.py

@@ -248,7 +248,7 @@ class FakeDriver(base.BaseDriver):
                                  batch_size, batch_timeout):
         targets = [
             oslo_messaging.Target(
-                topic='{}.{}'.format(target.topic, priority),
+                topic=f'{target.topic}.{priority}',
                 exchange=target.exchange)
             for target, priority in targets_and_priorities]
         listener = FakeListener(self._exchange_manager, targets, pool)

oslo_messaging/_drivers/impl_rabbit.py

@@ -1366,7 +1366,7 @@ class Connection:
                         # already do that for other connection
                         try:
                             self.connection.drain_events(timeout=0.001)
-                        except socket.timeout:
+                        except TimeoutError:
                             pass
                     # NOTE(hberaud): In a clustered rabbitmq when
                     # a node disappears, we get a ConnectionRefusedError
@@ -1376,9 +1376,7 @@ class Connection:
                     # Catch these exceptions to ensure that we call
                     # ensure_connection for switching the
                     # connection destination.
-                    except (socket.timeout,
-                            ConnectionRefusedError,
-                            OSError,
+                    except (TimeoutError, ConnectionRefusedError, OSError,
                             kombu.exceptions.OperationalError,
                             amqp_ex.ConnectionForced) as exc:
                         LOG.info("A recoverable connection/channel error "
@@ -1462,7 +1460,7 @@ class Connection:
                 try:
                     self.connection.drain_events(timeout=poll_timeout)
                     return
-                except socket.timeout:
+                except TimeoutError:
                     poll_timeout = timer.check_return(
                         _raise_timeout, maximum=self._poll_timeout)
                 except self.connection.channel_errors as exc:
@@ -1533,7 +1531,7 @@ class Connection:
                 unique = self._q_manager.get()
             else:
                 unique = uuid.uuid4().hex
-            queue_name = '{}_fanout_{}'.format(topic, unique)
+            queue_name = f'{topic}_fanout_{unique}'
         LOG.debug('Creating fanout queue: %s', queue_name)
 
         is_durable = (self.rabbit_transient_quorum_queue or

oslo_messaging/hacking/checks.py

@@ -124,7 +124,7 @@ class CheckForLoggingIssues(BaseASTChecker):
 
     def visit_ImportFrom(self, node):
         for alias in node.names:
-            full_name = '{}.{}'.format(node.module, alias.name)
+            full_name = f'{node.module}.{alias.name}'
             self._filter_imports(full_name, alias)
         return super().generic_visit(node)
 

oslo_messaging/notify/messaging.py

@@ -73,7 +73,7 @@ class MessagingDriver(notifier.Driver):
         priority = priority.lower()
         for topic in self.topics:
             target = oslo_messaging.Target(
-                topic='{}.{}'.format(topic, priority))
+                topic=f'{topic}.{priority}')
             try:
                 self.transport._send_notification(target, ctxt, message,
                                                   version=self.version,

oslo_messaging/rpc/client.py

@@ -80,7 +80,7 @@ class ClientSendError(exceptions.MessagingException):
     """Raised if we failed to send a message to a target."""
 
     def __init__(self, target, ex):
-        msg = 'Failed to send to target "{}": {}'.format(target, ex)
+        msg = f'Failed to send to target "{target}": {ex}'
         super().__init__(msg)
         self.target = target
         self.ex = ex

oslo_messaging/rpc/dispatcher.py

@@ -88,7 +88,7 @@ class UnsupportedVersion(RPCDispatcherError):
     def __init__(self, version, method=None):
         msg = "Endpoint does not support RPC version %s" % version
         if method:
-            msg = "{}. Attempted method: {}".format(msg, method)
+            msg = f"{msg}. Attempted method: {method}"
         super().__init__(msg)
         self.version = version
         self.method = method
@@ -177,7 +177,7 @@ class RPCDispatcher(dispatcher.DispatcherBase):
                          " for namespace and version filtering.  It must" + \
                          " be of type oslo_messaging.Target. Do not" + \
                          " define an Endpoint method named 'target'"
-                raise TypeError("{}: endpoint={}".format(errmsg, ep))
+                raise TypeError(f"{errmsg}: endpoint={ep}")
 
             # Check if we have an attribute named 'oslo_rpc_server_ping'
             oslo_rpc_server_ping = getattr(ep, 'oslo_rpc_server_ping', None)
@@ -186,7 +186,7 @@ class RPCDispatcher(dispatcher.DispatcherBase):
                          " attribute which can be use to ping the" + \
                          " endpoint. Please avoid using any oslo_* " + \
                          " naming."
-                LOG.warning("{} (endpoint={})".format(errmsg, ep))
+                LOG.warning(f"{errmsg} (endpoint={ep})")
 
         self.endpoints = endpoints
 

oslo_messaging/server.py

@@ -65,7 +65,7 @@ class ExecutorLoadFailure(MessagingServerError):
     """Raised if an executor can't be loaded."""
 
     def __init__(self, executor, ex):
-        msg = 'Failed to load executor "{}": {}'.format(executor, ex)
+        msg = f'Failed to load executor "{executor}": {ex}'
         super().__init__(msg)
         self.executor = executor
         self.ex = ex
@@ -75,7 +75,7 @@ class ServerListenError(MessagingServerError):
     """Raised if we failed to listen on a target."""
 
     def __init__(self, target, ex):
-        msg = 'Failed to listen on target "{}": {}'.format(target, ex)
+        msg = f'Failed to listen on target "{target}": {ex}'
         super().__init__(msg)
         self.target = target
         self.ex = ex
@@ -159,7 +159,7 @@ class _OrderedTask:
                               `timeout_timer` expires while waiting.
         """
         with self._cond:
-            msg = '{} is waiting for {} to complete'.format(caller, self._name)
+            msg = f'{caller} is waiting for {self._name} to complete'
             self._wait(lambda: not self.complete,
                        msg, log_after, timeout_timer)
 

oslo_messaging/tests/drivers/test_impl_rabbit.py

@@ -778,7 +778,7 @@ def _declare_queue(target):
                                          type='topic',
                                          durable=False,
                                          auto_delete=False)
-        topic = '{}.{}'.format(target.topic, target.server)
+        topic = f'{target.topic}.{target.server}'
         queue = kombu.entity.Queue(name=topic,
                                    channel=channel,
                                    exchange=exchange,
@@ -928,7 +928,7 @@ def _create_producer(target):
                                          type='topic',
                                          durable=False,
                                          auto_delete=False)
-        topic = '{}.{}'.format(target.topic, target.server)
+        topic = f'{target.topic}.{target.server}'
         producer = kombu.messaging.Producer(exchange=exchange,
                                             channel=channel,
                                             routing_key=topic)

oslo_messaging/tests/functional/notify/test_logger.py

@@ -50,7 +50,7 @@ class LoggingNotificationHandlerTestCase(utils.SkipIfNoTransportURL):
 
     def test_logging(self):
         # NOTE(gtt): Using different topic to make tests run in parallel
-        topic = 'test_logging_{}_driver_{}'.format(self.priority, self.driver)
+        topic = f'test_logging_{self.priority}_driver_{self.driver}'
 
         if self.notify_url.startswith("kafka://"):
             self.conf.set_override('consumer_group', str(uuid.uuid4()),

oslo_messaging/tests/functional/utils.py

@@ -253,7 +253,7 @@ class InvalidDistribution:
         self.wrong_order = []
 
     def describe(self):
-        text = "Sent {}, got {}; ".format(self.original, self.received)
+        text = f"Sent {self.original}, got {self.received}; "
         e1 = ["%r was missing" % m for m in self.missing]
         e2 = ["%r was not expected" % m for m in self.extra]
         e3 = ["{!r} expected before {!r}".format(

oslo_messaging/tests/rpc/test_dispatcher.py

@@ -214,7 +214,7 @@ class TestDispatcher(test_utils.BaseTestCase):
                         self.ctxt, **self.msg.get('args', {}))
                 else:
                     self.assertEqual(0, method.call_count,
-                                     'method: {}'.format(method))
+                                     f'method: {method}')
 
 
 class TestDispatcherWithPingEndpoint(test_utils.BaseTestCase):

oslo_messaging/transport.py

@@ -184,7 +184,7 @@ class DriverLoadFailure(exceptions.MessagingException):
     """Raised if a transport driver can't be loaded."""
 
     def __init__(self, driver, ex):
-        msg = 'Failed to load transport driver "{}": {}'.format(driver, ex)
+        msg = f'Failed to load transport driver "{driver}": {ex}'
         super().__init__(msg)
         self.driver = driver
         self.ex = ex