Add Python Black format check and apply format changes

Bring this repo in line with our standards to use Python Black
formatting conventions, and enforce it in the lint checks.

Author: johnsca

loadbalancer_interface/base.py

@@ -19,36 +19,40 @@ def __init__(self, charm, relation_name):
         # Future-proof against the need to evolve the relation protocol
         # by ensuring that we agree on a version number before starting.
         # This may or may not be made moot by a future feature in Juju.
-        for event in (charm.on[relation_name].relation_created,
-                      charm.on.leader_elected,
-                      charm.on.upgrade_charm):
+        for event in (
+            charm.on[relation_name].relation_created,
+            charm.on.leader_elected,
+            charm.on.upgrade_charm,
+        ):
             self.framework.observe(event, self._set_version)
 
     def _set_version(self, event):
         if self.unit.is_leader():
-            if hasattr(event, 'relation'):
+            if hasattr(event, "relation"):
                 relations = [event.relation]
             else:
                 relations = self.model.relations.get(self.relation_name, [])
             for relation in relations:
-                relation.data[self.app]['version'] = str(schemas.max_version)
+                relation.data[self.app]["version"] = str(schemas.max_version)
 
     @cached_property
     def relations(self):
         relations = self.model.relations.get(self.relation_name, [])
-        return [relation
-                for relation in sorted(relations, key=attrgetter('id'))
-                if self._schema(relation)]
+        return [
+            relation
+            for relation in sorted(relations, key=attrgetter("id"))
+            if self._schema(relation)
+        ]
 
     def _schema(self, relation=None):
         if relation is None:
             return schemas.versions[schemas.max_version]
         if relation.app not in relation.data:
             return None
         data = relation.data[relation.app]
-        if 'version' not in data:
+        if "version" not in data:
             return None
-        remote_version = int(data['version'])
+        remote_version = int(data["version"])
         return schemas.versions[min((schemas.max_version, remote_version))]
 
     @property

loadbalancer_interface/consumer.py

@@ -21,8 +21,8 @@ class LBConsumersEvents(ObjectEvents):
 
 
 class LBConsumers(VersionedInterface):
-    """ API used to interact with consumers of a loadbalancer provider.
-    """
+    """API used to interact with consumers of a loadbalancer provider."""
+
     state = StoredState()
     on = LBConsumersEvents()
 
@@ -31,9 +31,11 @@ def __init__(self, charm, relation_name):
         self.relation_name = relation_name
         self.state.set_default(known_requests={})
 
-        for event in (charm.on[relation_name].relation_created,
-                      charm.on[relation_name].relation_joined,
-                      charm.on[relation_name].relation_changed):
+        for event in (
+            charm.on[relation_name].relation_created,
+            charm.on[relation_name].relation_joined,
+            charm.on[relation_name].relation_changed,
+        ):
             self.framework.observe(event, self._check_consumers)
 
     def _check_consumers(self, event):
@@ -42,8 +44,7 @@ def _check_consumers(self, event):
 
     @cached_property
     def all_requests(self):
-        """ A list of all current consumer requests.
-        """
+        """A list of all current consumer requests."""
         if not self.unit.is_leader():
             # Only the leader can process requests, so avoid mistakes
             # by not even reading the requests if not the leader.
@@ -54,17 +55,15 @@ def all_requests(self):
             local_data = relation.data[self.app]
             remote_data = relation.data[relation.app]
             for key, request_sdata in sorted(remote_data.items()):
-                if not key.startswith('request_'):
+                if not key.startswith("request_"):
                     continue
-                name = key[len('request_'):]
-                response_sdata = local_data.get('response_' + name)
-                request = schema.Request.loads(name,
-                                               request_sdata,
-                                               response_sdata)
+                name = key[len("request_") :]
+                response_sdata = local_data.get("response_" + name)
+                request = schema.Request.loads(name, request_sdata, response_sdata)
                 request.relation = relation
                 if not request.backends:
-                    for unit in sorted(relation.units, key=attrgetter('name')):
-                        addr = relation.data[unit].get('ingress-address')
+                    for unit in sorted(relation.units, key=attrgetter("name")):
+                        addr = relation.data[unit].get("ingress-address")
                         if addr:
                             request.backends.append(addr)
                 requests.append(request)
@@ -73,53 +72,56 @@ def all_requests(self):
 
     @property
     def new_requests(self):
-        """ A list of requests with changes or no response.
-        """
-        return [request for request in self.all_requests
-                if request.hash != self.state.known_requests[request.id]]
+        """A list of requests with changes or no response."""
+        return [
+            request
+            for request in self.all_requests
+            if request.hash != self.state.known_requests[request.id]
+        ]
 
     @property
     def removed_requests(self):
-        """ A list of requests which have been removed, either explicitly or
+        """A list of requests which have been removed, either explicitly or
         because the relation was removed.
         """
         current_ids = {request.id for request in self.all_requests}
         unknown_ids = self.state.known_requests.keys() - current_ids
         schema = self._schema()
-        return [schema.Request._from_id(req_id, self.relations)
-                for req_id in sorted(unknown_ids)]
+        return [
+            schema.Request._from_id(req_id, self.relations)
+            for req_id in sorted(unknown_ids)
+        ]
 
     def send_response(self, request):
-        """ Send a specific request's response.
-        """
+        """Send a specific request's response."""
         request.response.received_hash = request.sent_hash
-        key = 'response_' + request.name
+        key = "response_" + request.name
         request.relation.data[self.app][key] = request.response.dumps()
         self.state.known_requests[request.id] = request.hash
         if not self.new_requests:
             try:
                 from charms.reactive import clear_flag
-                prefix = 'endpoint.' + self.relation_name
-                clear_flag(prefix + '.requests_changed')
+
+                prefix = "endpoint." + self.relation_name
+                clear_flag(prefix + ".requests_changed")
             except ImportError:
                 pass  # not being used in a reactive charm
 
     def revoke_response(self, request):
-        """ Revoke / remove the response for a given request.
-        """
+        """Revoke / remove the response for a given request."""
         if request.id:
             self.state.known_requests.pop(request.id, None)
         if request.relation:
-            key = 'response_' + request.name
+            key = "response_" + request.name
             request.relation.data.get(self.app, {}).pop(key, None)
 
     @property
     def is_changed(self):
         return bool(self.new_requests or self.removed_requests)
 
     def manage_flags(self):
-        """ Used to interact with charms.reactive-base charms.
-        """
+        """Used to interact with charms.reactive-base charms."""
         from charms.reactive import toggle_flag
-        prefix = 'endpoint.' + self.relation_name
-        toggle_flag(prefix + '.requests_changed', self.is_changed)
+
+        prefix = "endpoint." + self.relation_name
+        toggle_flag(prefix + ".requests_changed", self.is_changed)

loadbalancer_interface/provider.py

@@ -25,8 +25,8 @@ class LBProviderEvents(ObjectEvents):
 
 
 class LBProvider(VersionedInterface):
-    """ API used to interact with the provider of loadbalancers.
-    """
+    """API used to interact with the provider of loadbalancers."""
+
     state = StoredState()
     on = LBProviderEvents()
 
@@ -35,14 +35,15 @@ def __init__(self, charm, relation_name):
         self.relation_name = relation_name
         # just call this to enforce that only one app can be related
         self.model.get_relation(relation_name)
-        self.state.set_default(response_hashes={},
-                               was_available=False)
-
-        for event in (charm.on[relation_name].relation_created,
-                      charm.on[relation_name].relation_joined,
-                      charm.on[relation_name].relation_changed,
-                      charm.on[relation_name].relation_departed,
-                      charm.on[relation_name].relation_broken):
+        self.state.set_default(response_hashes={}, was_available=False)
+
+        for event in (
+            charm.on[relation_name].relation_created,
+            charm.on[relation_name].relation_joined,
+            charm.on[relation_name].relation_changed,
+            charm.on[relation_name].relation_departed,
+            charm.on[relation_name].relation_broken,
+        ):
             self.framework.observe(event, self._check_provider)
 
     def _check_provider(self, event):
@@ -63,19 +64,19 @@ def relation(self):
         return self.relations[0] if self.relations else None
 
     def get_request(self, name):
-        """ Get or create a Load Balancer Request object.
+        """Get or create a Load Balancer Request object.
 
         May raise a ModelError if unable to create a request.
         """
         if not self.charm.unit.is_leader():
-            raise ModelError('Unit is not leader')
+            raise ModelError("Unit is not leader")
         if not self.relation:
-            raise ModelError('Relation not available')
+            raise ModelError("Relation not available")
         schema = self._schema(self.relation)
         local_data = self.relation.data[self.app]
         remote_data = self.relation.data[self.relation.app]
-        request_key = 'request_' + name
-        response_key = 'response_' + name
+        request_key = "request_" + name
+        response_key = "response_" + name
         if request_key in local_data:
             request_sdata = local_data[request_key]
             response_sdata = remote_data.get(response_key)
@@ -85,7 +86,7 @@ def get_request(self, name):
         return request
 
     def get_response(self, name):
-        """ Get a specific Load Balancer Response by name.
+        """Get a specific Load Balancer Response by name.
 
         This is equivalent to `get_request(name).response`, except that it
         will return `None` if the response is not available.
@@ -98,85 +99,85 @@ def get_response(self, name):
         return request.response
 
     def send_request(self, request):
-        """ Send a specific request.
+        """Send a specific request.
 
         May raise a ModelError if unable to send the request.
         """
         if not self.charm.unit.is_leader():
-            raise ModelError('Unit is not leader')
+            raise ModelError("Unit is not leader")
         if not self.relation:
-            raise ModelError('Relation not available')
+            raise ModelError("Relation not available")
         # The sent_hash is used to tell when the provider's response has been
         # updated to match our request. We can't used the request hash computed
         # on the providing side because it may not match due to default values
         # being filled in on that side (e.g., the backend addresses).
         request.sent_hash = request.hash
-        key = 'request_' + request.name
+        key = "request_" + request.name
         self.relation.data[self.app][key] = request.dumps()
 
     def remove_request(self, name):
-        """ Remove a specific request.
+        """Remove a specific request.
 
         May raise a ModelError if unable to remove the request.
         """
         if not self.charm.unit.is_leader():
-            raise ModelError('Unit is not leader')
+            raise ModelError("Unit is not leader")
         if not self.relation:
             return
-        key = 'request_' + name
+        key = "request_" + name
         self.relation.data[self.app].pop(key, None)
         self.state.response_hashes.pop(name, None)
 
     @property
     def all_requests(self):
-        """ A list of all requests which have been made.
-        """
+        """A list of all requests which have been made."""
         requests = []
         if self.relation:
             for key in sorted(self.relation.data[self.app].keys()):
-                if not key.startswith('request_'):
+                if not key.startswith("request_"):
                     continue
-                requests.append(self.get_request(key[len('request_'):]))
+                requests.append(self.get_request(key[len("request_") :]))
         return requests
 
     @property
     def revoked_responses(self):
-        """ A list of responses which are no longer available.
-        """
-        return [request.response
-                for request in self.all_requests
-                if not request.response
-                and request.name in self.state.response_hashes]
+        """A list of responses which are no longer available."""
+        return [
+            request.response
+            for request in self.all_requests
+            if not request.response and request.name in self.state.response_hashes
+        ]
 
     @cached_property
     def all_responses(self):
-        """ A list of all responses which are available.
-        """
-        return [request.response
-                for request in self.all_requests
-                if request.response]
+        """A list of all responses which are available."""
+        return [request.response for request in self.all_requests if request.response]
 
     @cached_property
     def complete_responses(self):
-        """ A list of all responses which are up to date with their associated
+        """A list of all responses which are up to date with their associated
         request.
         """
-        return [request.response
-                for request in self.all_requests
-                if request.response.received_hash == request.sent_hash]
+        return [
+            request.response
+            for request in self.all_requests
+            if request.response.received_hash == request.sent_hash
+        ]
 
     @property
     def new_responses(self):
-        """ A list of complete responses which have not yet been acknowledged as
+        """A list of complete responses which have not yet been acknowledged as
         handled or which have changed.
         """
         acked_responses = self.state.response_hashes
-        return [response
-                for response in self.complete_responses
-                if response.hash != acked_responses.get(response.name)]
+        return [
+            response
+            for response in self.complete_responses
+            if response.hash != acked_responses.get(response.name)
+        ]
 
     def ack_response(self, response):
-        """ Acknowledge that a given response has been handled.
+        """Acknowledge that a given response has been handled.
 
         Can be called on a revoked response as well to remove it
         from the revoked_responses list.
@@ -188,8 +189,9 @@ def ack_response(self, response):
         if not self.is_changed:
             try:
                 from charms.reactive import clear_flag
-                prefix = 'endpoint.' + self.relation_name
-                clear_flag(prefix + '.responses_changed')
+
+                prefix = "endpoint." + self.relation_name
+                clear_flag(prefix + ".responses_changed")
             except ImportError:
                 pass  # not being used in a reactive charm
 
@@ -206,9 +208,9 @@ def can_request(self):
         return self.is_available and self.unit.is_leader()
 
     def manage_flags(self):
-        """ Used to interact with charms.reactive-base charms.
-        """
+        """Used to interact with charms.reactive-base charms."""
         from charms.reactive import toggle_flag
-        prefix = 'endpoint.' + self.relation_name
-        toggle_flag(prefix + '.available', self.is_available)
-        toggle_flag(prefix + '.responses_changed', self.is_changed)
+
+        prefix = "endpoint." + self.relation_name
+        toggle_flag(prefix + ".available", self.is_available)
+        toggle_flag(prefix + ".responses_changed", self.is_changed)