black

Author: justinc1

plugins/module_utils/client.py

@@ -59,15 +59,11 @@ class Response:
     # Response(raw_resp) would be simpler.
     # How is this used in other projects? Jure?
     # Maybe we need/want both.
-    def __init__(
-        self, status: int, data: Any, headers: Optional[dict[Any, Any]] = None
-    ):
+    def __init__(self, status: int, data: Any, headers: Optional[dict[Any, Any]] = None):
         self.status = status
         self.data = data
         # [('h1', 'v1'), ('H2', 'V2')] -> {'h1': 'v1', 'h2': 'V2'}
-        self.headers = (
-            dict((k.lower(), v) for k, v in dict(headers).items()) if headers else {}
-        )
+        self.headers = dict((k.lower(), v) for k, v in dict(headers).items()) if headers else {}
 
         self._json = None
 
@@ -92,8 +88,7 @@ def __init__(
     ):
         if not (host or "").startswith(("https://", "http://")):
             raise ScaleComputingError(
-                "Invalid instance host value: '{0}'. "
-                "Value must start with 'https://' or 'http://'".format(host)
+                "Invalid instance host value: '{0}'. " "Value must start with 'https://' or 'http://'".format(host)
             )
 
         self.host = host
@@ -213,23 +208,14 @@ def _request_no_log(
         except URLError as e:
             # TODO: Add other errors here; we need to handle them in modules.
             # TimeoutError is handled in the rest_client
-            if (
-                e.args
-                and isinstance(e.args, tuple)
-                and isinstance(e.args[0], ConnectionRefusedError)
-            ):
+            if e.args and isinstance(e.args, tuple) and isinstance(e.args[0], ConnectionRefusedError):
                 raise ConnectionRefusedError(e.reason)
-            elif (
-                e.args
-                and isinstance(e.args, tuple)
-                and isinstance(e.args[0], ConnectionResetError)
-            ):
+            elif e.args and isinstance(e.args, tuple) and isinstance(e.args[0], ConnectionResetError):
                 raise ConnectionResetError(e.reason)
             elif (
                 e.args
                 and isinstance(e.args, tuple)
-                and type(e.args[0])
-                in [ssl.SSLEOFError, ssl.SSLZeroReturnError, ssl.SSLSyscallError]
+                and type(e.args[0]) in [ssl.SSLEOFError, ssl.SSLZeroReturnError, ssl.SSLSyscallError]
             ):
                 raise type(e.args[0])(e)
             raise ScaleComputingError(e.reason)
@@ -247,9 +233,7 @@ def request(
     ) -> Response:
         # Make sure we only have one kind of payload
         if data is not None and binary_data is not None:
-            raise AssertionError(
-                "Cannot have JSON and binary payload in a single request."
-            )
+            raise AssertionError("Cannot have JSON and binary payload in a single request.")
         escaped_path = quote(path.strip("/"))
         if escaped_path:
             escaped_path = "/" + escaped_path
@@ -268,9 +252,7 @@ def request(
             )
         elif binary_data is not None:
             headers["Content-type"] = "application/octet-stream"
-            return self._request(
-                method, url, data=binary_data, headers=headers, timeout=timeout
-            )
+            return self._request(method, url, data=binary_data, headers=headers, timeout=timeout)
         return self._request(method, url, data=data, headers=headers, timeout=timeout)
 
     def get(

plugins/module_utils/cluster.py

@@ -65,23 +65,15 @@ def __eq__(self, other: object) -> bool:
 
     @classmethod
     def get(cls, rest_client: RestClient, must_exist: bool = True) -> Cluster:
-        hypercore_dict = rest_client.get_record(
-            "/rest/v1/Cluster", must_exist=must_exist
-        )
+        hypercore_dict = rest_client.get_record("/rest/v1/Cluster", must_exist=must_exist)
         cluster = cls.from_hypercore(hypercore_dict)  # type: ignore # cluster never None
         return cluster
 
-    def update_name(
-        self, rest_client: RestClient, name_new: str, check_mode: bool = False
-    ) -> TypedTaskTag:
-        return rest_client.update_record(
-            f"/rest/v1/Cluster/{self.uuid}", dict(clusterName=name_new), check_mode
-        )
+    def update_name(self, rest_client: RestClient, name_new: str, check_mode: bool = False) -> TypedTaskTag:
+        return rest_client.update_record(f"/rest/v1/Cluster/{self.uuid}", dict(clusterName=name_new), check_mode)
 
     @staticmethod
-    def shutdown(
-        rest_client: RestClient, force_shutdown: bool = False, check_mode: bool = False
-    ) -> None:
+    def shutdown(rest_client: RestClient, force_shutdown: bool = False, check_mode: bool = False) -> None:
         try:
             rest_client.create_record(
                 "/rest/v1/Cluster/shutdown",

plugins/module_utils/disk.py

@@ -126,11 +126,8 @@ def from_hypercore(cls, hypercore_data: dict[Any, Any]) -> Optional[Disk]:
                 disable_snapshotting=hypercore_data["disableSnapshotting"],
                 # Hypercore sometimes returns values outside the mapping table, so we set it to default.
                 tiering_priority_factor=(
-                    TIERING_PRIORITY_MAPPING_FROM_HYPERCORE[
-                        hypercore_data["tieringPriorityFactor"]
-                    ]
-                    if hypercore_data["tieringPriorityFactor"]
-                    in TIERING_PRIORITY_MAPPING_FROM_HYPERCORE
+                    TIERING_PRIORITY_MAPPING_FROM_HYPERCORE[hypercore_data["tieringPriorityFactor"]]
+                    if hypercore_data["tieringPriorityFactor"] in TIERING_PRIORITY_MAPPING_FROM_HYPERCORE
                     else TIERING_PRIORITY_DEFAULT
                 ),
                 mount_points=hypercore_data["mountPoints"],
@@ -225,10 +222,6 @@ def needs_reboot(self, action: str, desired_disk=None) -> bool:
         return False
 
     @classmethod
-    def get_by_uuid(
-        cls, uuid: str, rest_client: RestClient, must_exist: bool
-    ) -> Optional[Disk]:
-        hypercore_dict = rest_client.get_record(
-            f"/rest/v1/VirDomainBlockDevice/{uuid}", must_exist=must_exist
-        )
+    def get_by_uuid(cls, uuid: str, rest_client: RestClient, must_exist: bool) -> Optional[Disk]:
+        hypercore_dict = rest_client.get_record(f"/rest/v1/VirDomainBlockDevice/{uuid}", must_exist=must_exist)
         return cls.from_hypercore(hypercore_dict)

plugins/module_utils/dns_config.py

@@ -76,9 +76,7 @@ def __eq__(self, other):
     @classmethod
     def get_by_uuid(cls, ansible_dict, rest_client, must_exist=False):
         query = get_query(ansible_dict, "uuid", ansible_hypercore_map=dict(uuid="uuid"))
-        hypercore_dict = rest_client.get_record(
-            "/rest/v1/DNSConfig", query, must_exist=must_exist
-        )
+        hypercore_dict = rest_client.get_record("/rest/v1/DNSConfig", query, must_exist=must_exist)
         dns_config_from_hypercore = DNSConfig.from_hypercore(hypercore_dict)
         return dns_config_from_hypercore
 

plugins/module_utils/email_alert.py

@@ -105,9 +105,7 @@ def get_by_uuid(
         must_exist: bool = False,
     ) -> Optional[EmailAlert]:
         query = get_query(ansible_dict, "uuid", ansible_hypercore_map=dict(uuid="uuid"))
-        hypercore_dict = rest_client.get_record(
-            "/rest/v1/AlertEmailTarget", query, must_exist=must_exist
-        )
+        hypercore_dict = rest_client.get_record("/rest/v1/AlertEmailTarget", query, must_exist=must_exist)
         alert_email_from_hypercore = cls.from_hypercore(hypercore_dict)
         return alert_email_from_hypercore
 
@@ -123,9 +121,7 @@ def get_by_email(
             "email",
             ansible_hypercore_map=dict(email="emailAddress"),
         )
-        hypercore_dict = rest_client.get_record(
-            "/rest/v1/AlertEmailTarget", query, must_exist=must_exist
-        )
+        hypercore_dict = rest_client.get_record("/rest/v1/AlertEmailTarget", query, must_exist=must_exist)
 
         alert_email_from_hypercore = EmailAlert.from_hypercore(hypercore_dict)
         return alert_email_from_hypercore
@@ -141,13 +137,9 @@ def list_by_email(
             "email",
             ansible_hypercore_map=dict(email="emailAddress"),
         )
-        hypercore_dict_list = rest_client.list_records(
-            "/rest/v1/AlertEmailTarget", query
-        )
+        hypercore_dict_list = rest_client.list_records("/rest/v1/AlertEmailTarget", query)
 
-        alert_email_from_hypercore_list = [
-            EmailAlert.from_hypercore(hc_dict) for hc_dict in hypercore_dict_list
-        ]
+        alert_email_from_hypercore_list = [EmailAlert.from_hypercore(hc_dict) for hc_dict in hypercore_dict_list]
         return alert_email_from_hypercore_list
 
     @classmethod
@@ -169,9 +161,7 @@ def create(
         payload: Dict[Any, Any],
         check_mode: bool = False,
     ):
-        task_tag = rest_client.create_record(
-            "/rest/v1/AlertEmailTarget/", payload, check_mode
-        )
+        task_tag = rest_client.create_record("/rest/v1/AlertEmailTarget/", payload, check_mode)
         email_alert = cls.get_by_uuid(
             dict(uuid=task_tag["createdUUID"]),
             rest_client,
@@ -185,9 +175,7 @@ def update(
         payload: Dict[Any, Any],
         check_mode: bool = False,
     ) -> None:
-        rest_client.update_record(
-            f"/rest/v1/AlertEmailTarget/{self.uuid}", payload, check_mode
-        )
+        rest_client.update_record(f"/rest/v1/AlertEmailTarget/{self.uuid}", payload, check_mode)
 
     def delete(
         self,
@@ -200,7 +188,5 @@ def test(
         self,
         rest_client: RestClient,
     ) -> TypedTaskTag:
-        response = rest_client.client.post(
-            f"/rest/v1/AlertEmailTarget/{self.uuid}/test", None
-        )
+        response = rest_client.client.post(f"/rest/v1/AlertEmailTarget/{self.uuid}/test", None)
         return response

plugins/module_utils/errors.py

@@ -79,9 +79,7 @@ def __init__(self, data: Union[str, Exception]):
 
 class ReplicationNotUnique(ScaleComputingError):
     def __init__(self, data: Union[str, Exception]):
-        self.message = (
-            f"There is already a replication on - {data} - virtual machine"
-        )
+        self.message = f"There is already a replication on - {data} - virtual machine"
         super(ReplicationNotUnique, self).__init__(self.message)
 
 
@@ -93,9 +91,7 @@ def __init__(self, data: Union[str, Exception]):
 
 class SMBServerNotFound(ScaleComputingError):
     def __init__(self, data: Union[str, Exception]):
-        self.message = "SMB server is either not connected or not in the same network - {0}".format(
-            data
-        )
+        self.message = "SMB server is either not connected or not in the same network - {0}".format(data)
         super(SMBServerNotFound, self).__init__(self.message)
 
 

plugins/module_utils/hypercore_version.py

@@ -42,14 +42,8 @@ def __init__(self, rest_client: RestClient):
     def version(self) -> str:
         if not self._version:
             record = self._rest_client.get_record("/rest/v1/Cluster")
-            if (
-                record is None
-                or "icosVersion" not in record
-                or not isinstance(record["icosVersion"], str)
-            ):
-                raise AssertionError(
-                    "HyperCore version not found in REST API response."
-                )
+            if record is None or "icosVersion" not in record or not isinstance(record["icosVersion"], str):
+                raise AssertionError("HyperCore version not found in REST API response.")
             self._version = record["icosVersion"]
         return self._version
 
@@ -182,9 +176,7 @@ def from_ansible(cls, ansible_data: dict[Any, Any]) -> None:
         pass
 
     @classmethod
-    def from_hypercore(
-        cls, hypercore_data: Optional[dict[Any, Any]]
-    ) -> Optional[Update]:
+    def from_hypercore(cls, hypercore_data: Optional[dict[Any, Any]]) -> Optional[Update]:
         if not hypercore_data:
             return None
         return cls(
@@ -243,9 +235,7 @@ def get(
     ) -> Optional[Update]:
         # api has a bug - the endpoint "/rest/v1/Update/{uuid}" returns a list of all available updates (and uuid can actually be anything),
         # that is why query is used
-        update = rest_client.get_record(
-            f"/rest/v1/Update/{uuid}", query=dict(uuid=uuid), must_exist=must_exist
-        )
+        update = rest_client.get_record(f"/rest/v1/Update/{uuid}", query=dict(uuid=uuid), must_exist=must_exist)
         return cls.from_hypercore(update)
 
     @classmethod
@@ -255,9 +245,7 @@ def apply_update(
         version: str,
         check_mode: bool = False,
     ) -> TypedTaskTag:
-        return rest_client.create_record(
-            f"/rest/v1/Update/{version}/apply", payload=None, check_mode=check_mode
-        )
+        return rest_client.create_record(f"/rest/v1/Update/{version}/apply", payload=None, check_mode=check_mode)
 
 
 class UpdateStatus(PayloadMapper):
@@ -300,9 +288,7 @@ def from_hypercore(cls, hypercore_data: dict[Any, Any]) -> UpdateStatus:
             to_build=hypercore_data["updateStatus"].get("toBuild"),
             to_version=hypercore_data["updateStatus"].get("toVersion"),
             percent=hypercore_data["updateStatus"].get("percent"),
-            update_status_details=hypercore_data["updateStatus"]["status"].get(
-                "statusdetails"
-            ),
+            update_status_details=hypercore_data["updateStatus"]["status"].get("statusdetails"),
             usernotes=hypercore_data["updateStatus"]["status"].get("usernotes"),
         )
 

plugins/module_utils/iso.py

@@ -16,9 +16,7 @@
 
 class ISO(PayloadMapper):
     # Variables in ISO are written in ansible-native format
-    def __init__(
-        self, name, uuid=None, size=-1, mounts=None, ready_for_insert=False, path=None
-    ):
+    def __init__(self, name, uuid=None, size=-1, mounts=None, ready_for_insert=False, path=None):
         if mounts is None:
             mounts = []
         self.uuid = uuid
@@ -47,10 +45,7 @@ def from_hypercore(cls, hypercore_data):
             uuid=hypercore_data["uuid"],
             name=hypercore_data["name"],
             size=hypercore_data["size"],
-            mounts=[
-                dict(vm_uuid=mount["vmUUID"], vm_name=mount["vmName"])
-                for mount in hypercore_data["mounts"]
-            ],
+            mounts=[dict(vm_uuid=mount["vmUUID"], vm_name=mount["vmName"]) for mount in hypercore_data["mounts"]],
             ready_for_insert=hypercore_data["readyForInsert"],
             path=hypercore_data["path"],
         )
@@ -95,11 +90,7 @@ def __str__(self):
         return super().__str__()
 
     def build_iso_post_paylaod(self):
-        return {
-            key: value
-            for key, value in self.to_hypercore().items()
-            if key in ("name", "size", "readyForInsert")
-        }
+        return {key: value for key, value in self.to_hypercore().items() if key in ("name", "size", "readyForInsert")}
 
     @classmethod
     def get_by_name(cls, ansible_dict, rest_client, must_exist=False):
@@ -108,9 +99,7 @@ def get_by_name(cls, ansible_dict, rest_client, must_exist=False):
         the record exists. If there is no record with such name, None is returned.
         """
         query = get_query(ansible_dict, "name", ansible_hypercore_map=dict(name="name"))
-        hypercore_dict = rest_client.get_record(
-            "/rest/v1/ISO", query, must_exist=must_exist
-        )
+        hypercore_dict = rest_client.get_record("/rest/v1/ISO", query, must_exist=must_exist)
         iso_from_hypercore = ISO.from_hypercore(hypercore_dict)
         return iso_from_hypercore
 

plugins/module_utils/nic.py

@@ -21,9 +21,7 @@
     "VIRTIO": "virtio",
     "INTEL_E1000": "INTEL_E1000",
 }
-FROM_ANSIBLE_TO_HYPERCORE_NIC_TYPE = {
-    v: k for k, v in FROM_HYPERCORE_TO_ANSIBLE_NIC_TYPE.items()
-}
+FROM_ANSIBLE_TO_HYPERCORE_NIC_TYPE = {v: k for k, v in FROM_HYPERCORE_TO_ANSIBLE_NIC_TYPE.items()}
 
 
 # Maybe create enums.py or scale_enums.py and move all enum classes there? @Jure @Justin
@@ -56,29 +54,13 @@ def __eq__(self, other):
         elif other.vlan_new is not None and not other.mac_new:
             return self.vlan == other.vlan_new and self.type == other.type
         elif self.mac_new and self.vlan_new is None:
-            return (
-                self.vlan == other.vlan
-                and self.type == other.type
-                and self.mac_new == other.mac
-            )
+            return self.vlan == other.vlan and self.type == other.type and self.mac_new == other.mac
         elif other.mac_new and other.vlan_new is None:
-            return (
-                self.vlan == other.vlan
-                and self.type == other.type
-                and self.mac == other.mac_new
-            )
+            return self.vlan == other.vlan and self.type == other.type and self.mac == other.mac_new
         elif self.vlan_new is not None and self.mac_new:
-            return (
-                self.vlan_new == other.vlan
-                and self.type == other.type
-                and self.mac_new == other.mac
-            )
+            return self.vlan_new == other.vlan and self.type == other.type and self.mac_new == other.mac
         elif other.vlan_new is not None and other.mac_new:
-            return (
-                self.vlan == other.vlan_new
-                and self.type == other.type
-                and self.mac == other.mac_new
-            )
+            return self.vlan == other.vlan_new and self.type == other.type and self.mac == other.mac_new
         return self.vlan == other.vlan and self.type == other.type
 
     @classmethod

plugins/module_utils/node.py

@@ -63,8 +63,6 @@ def __eq__(self, other):
 
     @classmethod
     def get_node(cls, query, rest_client, must_exist=False):
-        hypercore_dict = rest_client.get_record(
-            "/rest/v1/Node", query, must_exist=must_exist
-        )
+        hypercore_dict = rest_client.get_record("/rest/v1/Node", query, must_exist=must_exist)
         node_from_hypercore = cls.from_hypercore(hypercore_dict)
         return node_from_hypercore