Merge "Run pyupgrade to clean up Python 2 syntaxes"

Author: Zuul

.pre-commit-config.yaml

@@ -28,3 +28,8 @@ repos:
     hooks:
       - id: bandit
         args: ['-x', 'tests,tools']
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.18.0
+    hooks:
+      - id: pyupgrade
+        args: [--py3-only]

doc/source/conf.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright (C) 2020 Red Hat, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may

oslo_messaging/__init__.py

@@ -1,4 +1,3 @@
-
 # Copyright 2013 Red Hat, Inc.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may

oslo_messaging/_drivers/amqp.py

@@ -49,7 +49,7 @@ class RpcContext(rpc_common.CommonRpcContext):
     def __init__(self, **kwargs):
         self.msg_id = kwargs.pop('msg_id', None)
         self.reply_q = kwargs.pop('reply_q', None)
-        super(RpcContext, self).__init__(**kwargs)
+        super().__init__(**kwargs)
 
     def deepcopy(self):
         values = self.to_dict()
@@ -91,7 +91,7 @@ def pack_context(msg, context):
                for (key, value) in context_d)
 
 
-class _MsgIdCache(object):
+class _MsgIdCache:
     """This class checks any duplicate messages."""
 
     # NOTE: This value is considered can be a configuration item, but

oslo_messaging/_drivers/amqp1_driver/addressing.py

@@ -68,7 +68,7 @@ def keyify(address, service=SERVICE_RPC):
         return "String:{%s}" % address
 
 
-class Addresser(object):
+class Addresser:
     """Base class message bus address generator. Used to convert an
     oslo.messaging address into an AMQP 1.0 address string used over the
     connection to the message bus.
@@ -118,7 +118,7 @@ class LegacyAddresser(Addresser):
     """
     def __init__(self, default_exchange, server_prefix, broadcast_prefix,
                  group_prefix, vhost):
-        super(LegacyAddresser, self).__init__(default_exchange)
+        super().__init__(default_exchange)
         self._server_prefix = server_prefix
         self._broadcast_prefix = broadcast_prefix
         self._group_prefix = group_prefix
@@ -181,7 +181,7 @@ class RoutableAddresser(Addresser):
     def __init__(self, default_exchange, rpc_exchange, rpc_prefix,
                  notify_exchange, notify_prefix, unicast_tag, multicast_tag,
                  anycast_tag, vhost):
-        super(RoutableAddresser, self).__init__(default_exchange)
+        super().__init__(default_exchange)
         if not self._default_exchange:
             self._default_exchange = "openstack"
 
@@ -260,7 +260,7 @@ def _is_service(self, address, service):
                                   else self._notify_prefix)
 
 
-class AddresserFactory(object):
+class AddresserFactory:
     """Generates the proper Addresser based on configuration and the type of
     message bus the driver is connected to.
     """

oslo_messaging/_drivers/amqp1_driver/controller.py

@@ -52,7 +52,7 @@
 LOG = logging.getLogger(__name__)
 
 
-class Task(object):
+class Task:
     """Run a command on the eventloop thread, wait until it completes
     """
 
@@ -74,7 +74,7 @@ class SubscribeTask(Task):
     arriving from the target are given to the listener.
     """
     def __init__(self, target, listener, notifications=False):
-        super(SubscribeTask, self).__init__()
+        super().__init__()
         self._target = target()  # mutable - need a copy
         self._subscriber_id = listener.id
         self._in_queue = listener.incoming
@@ -95,7 +95,7 @@ class SendTask(Task):
     """
     def __init__(self, name, message, target, deadline, retry,
                  wait_for_ack, notification=False):
-        super(SendTask, self).__init__()
+        super().__init__()
         self.name = name
         # note: target can be either a Target class or a string
         # target is mutable - make copy
@@ -195,18 +195,18 @@ class RPCCallTask(SendTask):
     the destination.
     """
     def __init__(self, target, message, deadline, retry, wait_for_ack):
-        super(RPCCallTask, self).__init__("RPC Call", message, target,
-                                          deadline, retry, wait_for_ack)
+        super().__init__("RPC Call", message, target,
+                         deadline, retry, wait_for_ack)
         self._reply_link = None
         self._reply_msg = None
         self._msg_id = None
 
     def wait(self):
-        error = super(RPCCallTask, self).wait()
+        error = super().wait()
         return error or self._reply_msg
 
     def _prepare(self, sender):
-        super(RPCCallTask, self)._prepare(sender)
+        super()._prepare(sender)
         # reserve a message id for mapping the received response
         if self._msg_id:
             # already set so this is a re-transmit. To be safe cancel the old
@@ -224,15 +224,15 @@ def _on_reply(self, message):
 
     def _on_ack(self, state, info):
         if state != pyngus.SenderLink.ACCEPTED:
-            super(RPCCallTask, self)._on_ack(state, info)
+            super()._on_ack(state, info)
         # must wait for reply if ACCEPTED
 
     def _cleanup(self):
         if self._msg_id:
             self._reply_link.cancel_response(self._msg_id)
             self._msg_id = None
         self._reply_link = None
-        super(RPCCallTask, self)._cleanup()
+        super()._cleanup()
 
 
 class RPCMonitoredCallTask(RPCCallTask):
@@ -243,8 +243,8 @@ class RPCMonitoredCallTask(RPCCallTask):
     """
     def __init__(self, target, message, deadline, call_monitor_timeout,
                  retry, wait_for_ack):
-        super(RPCMonitoredCallTask, self).__init__(target, message, deadline,
-                                                   retry, wait_for_ack)
+        super().__init__(target, message, deadline,
+                         retry, wait_for_ack)
         assert call_monitor_timeout is not None  # nosec
         self._monitor_timeout = call_monitor_timeout
         self._monitor_timer = None
@@ -254,7 +254,7 @@ def _execute(self, controller):
         self._set_alarm = controller.processor.defer
         self._monitor_timer = self._set_alarm(self._call_timeout,
                                               self._monitor_timeout)
-        super(RPCMonitoredCallTask, self)._execute(controller)
+        super()._execute(controller)
 
     def _call_timeout(self):
         # monitor_timeout expired
@@ -274,22 +274,22 @@ def _on_reply(self, message):
             self._monitor_timer = self._set_alarm(self._call_timeout,
                                                   self._monitor_timeout)
         else:
-            super(RPCMonitoredCallTask, self)._on_reply(message)
+            super()._on_reply(message)
 
     def _cleanup(self):
         self._set_alarm = None
         if self._monitor_timer:
             self._monitor_timer.cancel()
             self._monitor_timer = None
-        super(RPCMonitoredCallTask, self)._cleanup()
+        super()._cleanup()
 
 
 class MessageDispositionTask(Task):
     """A task that updates the message disposition as accepted or released
     for a Server
     """
     def __init__(self, disposition, released=False):
-        super(MessageDispositionTask, self).__init__()
+        super().__init__()
         self._disposition = disposition
         self._released = released
 
@@ -311,7 +311,7 @@ class Sender(pyngus.SenderEventHandler):
     """A link for sending to a particular destination on the message bus.
     """
     def __init__(self, destination, scheduler, delay, service):
-        super(Sender, self).__init__()
+        super().__init__()
         self._destination = destination
         self._service = service
         self._address = None
@@ -537,8 +537,8 @@ def _send_pending(self):
                 self._send(self._pending_sends.popleft())
 
     def _open_link(self):
-        name = "openstack.org/om/sender/[%s]/%s" % (self._address,
-                                                    uuid.uuid4().hex)
+        name = "openstack.org/om/sender/[{}]/{}".format(self._address,
+                                                        uuid.uuid4().hex)
         link = self._connection.create_sender(name=name,
                                               source_address=self._address,
                                               target_address=self._address,
@@ -685,7 +685,8 @@ def attach(self, connection):
         """
         self._connection = connection
         for a in self._addresses:
-            name = "openstack.org/om/receiver/[%s]/%s" % (a, uuid.uuid4().hex)
+            name = "openstack.org/om/receiver/[{}]/{}".format(
+                a, uuid.uuid4().hex)
             r = self._open_link(a, name)
             self._receivers.append(r)
 
@@ -786,8 +787,8 @@ def _reopen_links(self):
 class RPCServer(Server):
     """Subscribes to RPC addresses"""
     def __init__(self, target, incoming, scheduler, delay, capacity):
-        super(RPCServer, self).__init__(target, incoming, scheduler, delay,
-                                        capacity)
+        super().__init__(target, incoming, scheduler, delay,
+                         capacity)
 
     def attach(self, connection, addresser):
         # Generate the AMQP 1.0 addresses for the base class
@@ -797,25 +798,25 @@ def attach(self, connection, addresser):
             addresser.anycast_address(self._target, SERVICE_RPC)
         ]
         # now invoke the base class with the generated addresses
-        super(RPCServer, self).attach(connection)
+        super().attach(connection)
 
 
 class NotificationServer(Server):
     """Subscribes to Notification addresses"""
     def __init__(self, target, incoming, scheduler, delay, capacity):
-        super(NotificationServer, self).__init__(target, incoming, scheduler,
-                                                 delay, capacity)
+        super().__init__(target, incoming, scheduler,
+                         delay, capacity)
 
     def attach(self, connection, addresser):
         # Generate the AMQP 1.0 addresses for the base class
         self._addresses = [
             addresser.anycast_address(self._target, SERVICE_NOTIFY)
         ]
         # now invoke the base class with the generated addresses
-        super(NotificationServer, self).attach(connection)
+        super().attach(connection)
 
 
-class Hosts(object):
+class Hosts:
     """An order list of TransportHost addresses. Connection failover progresses
     from one host to the next.  The default realm comes from the configuration
     and is only used if no realm is present in the URL.

oslo_messaging/_drivers/amqp1_driver/eventloop.py

@@ -44,7 +44,7 @@ def compute_timeout(offset):
     return math.ceil(time.monotonic() + offset)
 
 
-class _SocketConnection(object):
+class _SocketConnection:
     """Associates a pyngus Connection with a python network socket,
     and handles all connection-related I/O and timer events.
     """
@@ -71,7 +71,7 @@ def read_socket(self):
             try:
                 pyngus.read_socket_input(self.pyngus_conn, self.socket)
                 self.pyngus_conn.process(time.monotonic())
-            except (socket.timeout, socket.error) as e:
+            except (socket.timeout, OSError) as e:
                 # pyngus handles EAGAIN/EWOULDBLOCK and EINTER
                 self.pyngus_conn.close_input()
                 self.pyngus_conn.close_output()
@@ -83,7 +83,7 @@ def write_socket(self):
             try:
                 pyngus.write_socket_output(self.pyngus_conn, self.socket)
                 self.pyngus_conn.process(time.monotonic())
-            except (socket.timeout, socket.error) as e:
+            except (socket.timeout, OSError) as e:
                 # pyngus handles EAGAIN/EWOULDBLOCK and EINTER
                 self.pyngus_conn.close_output()
                 self.pyngus_conn.close_input()
@@ -104,7 +104,7 @@ def connect(self, host):
         my_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
         try:
             my_socket.connect(addr[0][4])
-        except socket.error as e:
+        except OSError as e:
             if e.errno != errno.EINPROGRESS:
                 error = "Socket connect failure '%s'" % str(e)
                 LOG.error("Socket connect failure '%s'", str(e))
@@ -159,10 +159,10 @@ def close(self):
             self.socket = None
 
 
-class Scheduler(object):
+class Scheduler:
     """Schedule callables to be run in the future.
     """
-    class Event(object):
+    class Event:
         # simply hold a reference to a callback that can be set to None if the
         # alarm is canceled
         def __init__(self, callback):
@@ -229,7 +229,7 @@ def _process(self):
                 pass
 
 
-class Requests(object):
+class Requests:
     """A queue of callables to execute from the eventloop thread's main
     loop.
     """
@@ -273,7 +273,7 @@ class Thread(threading.Thread):
     threads.
     """
     def __init__(self, container_name, node, command, pid):
-        super(Thread, self).__init__()
+        super().__init__()
 
         # callables from other threads:
         self._requests = Requests()
@@ -325,7 +325,8 @@ def alarm(self, request, deadline):
 
     def connect(self, host, handler, properties):
         """Get a _SocketConnection to a peer represented by url."""
-        key = "openstack.org/om/connection/%s:%s/" % (host.hostname, host.port)
+        key = "openstack.org/om/connection/{}:{}/".format(
+            host.hostname, host.port)
         # return pre-existing
         conn = self._container.get_connection(key)
         if conn:
@@ -379,7 +380,7 @@ def _main_loop(self):
             # and now we wait...
             try:
                 select.select(readfds, writefds, [], timeout)
-            except select.error as serror:
+            except OSError as serror:
                 if serror[0] == errno.EINTR:
                     LOG.warning("ignoring interrupt from select(): %s",
                                 str(serror))