pylint-lint

Avoid using next, input, open, type as function parameter name
Refactor a few for loop to use .items()

Signed-off-by: Justin Cinkelj <[email protected]>

Author: justinc1

plugins/module_utils/disk.py

@@ -53,7 +53,7 @@
 class Disk(PayloadMapper):
     def __init__(
         self,
-        type,
+        disk_type,
         slot,
         uuid=None,
         vm_uuid=None,
@@ -67,7 +67,7 @@ def __init__(
     ):
         self.uuid = uuid
         self.vm_uuid = vm_uuid
-        self.type = type
+        self.type = disk_type
         self.cache_mode = cache_mode
         self.size = size
         self.slot = slot
@@ -118,7 +118,7 @@ def from_hypercore(cls, hypercore_data: dict[Any, Any]) -> Optional[Disk]:
             return cls(
                 uuid=hypercore_data["uuid"],
                 vm_uuid=hypercore_data["virDomainUUID"],
-                type=hypercore_data["type"].lower(),
+                disk_type=hypercore_data["type"].lower(),
                 cache_mode=hypercore_data["cacheMode"].lower(),
                 size=hypercore_data["capacity"],
                 slot=hypercore_data["slot"],
@@ -156,7 +156,7 @@ def from_ansible(cls, ansible_data):
         else:
             size = None
         return cls(
-            type=disk_type,
+            disk_type=disk_type,
             slot=ansible_data["disk_slot"],
             size=size,
             cache_mode=ansible_data.get("cache_mode", None),

plugins/module_utils/support_tunnel.py

@@ -22,8 +22,8 @@
 
 
 class SupportTunnel(PayloadMapper):
-    def __init__(self, open: bool, code: Optional[int]):
-        self.open = open
+    def __init__(self, open_flag: bool, code: Optional[int]):
+        self.open = open_flag
         self.code = code
 
     @classmethod
@@ -36,12 +36,12 @@ def from_hypercore(
     ) -> SupportTunnel:
         # There is no None check since get_record is not used (support_tunnel's api behaves different)
         if not hypercore_data["tunnelOpen"]:
-            open = False
+            open_flag = False
             code = None
         else:
-            open = True
+            open_flag = True
             code = hypercore_data["tunnelOpen"]
-        return cls(open=open, code=code)
+        return cls(open_flag=open_flag, code=code)
 
     def to_hypercore(self) -> Any:
         pass

plugins/module_utils/utils.py

@@ -42,23 +42,23 @@ def validate_uuid(value):
 
 
 def get_query(
-    input: dict[Any, Any], *field_names: str, ansible_hypercore_map: dict[Any, Any]
+    query_filter: dict[Any, Any], *field_names: str, ansible_hypercore_map: dict[Any, Any]
 ):
     """
     Wrapps filter_dict and transform_ansible_to_hypercore_query. Prefer to use 'get_query' over filter_dict
     even if there's no mapping between hypercore and ansible columns for the sake of verbosity and consistency
     """
-    ansible_query = filter_dict(input, *field_names)
+    ansible_query = filter_dict(query_filter, *field_names)
     hypercore_query = transform_query(ansible_query, ansible_hypercore_map)
     return hypercore_query
 
 
-def filter_dict(input, *field_names):
+def filter_dict(query_filter, *field_names):
     output = {}
     for field_name in field_names:
-        if field_name not in input:
+        if field_name not in query_filter:
             continue
-        value = input[field_name]
+        value = query_filter[field_name]
         if value is not None:
             output[field_name] = value
     return output

plugins/module_utils/vm.py

@@ -176,8 +176,8 @@ def from_hypercore_to_ansible(cls, vm_dict: dict) -> str:
         # and use machineTypeKeyword if present.
         if "machineTypeKeyword" in vm_dict:
             _map_hypercore_machine_type_keyword_to_ansible = {
-                cls._map_ansible_to_hypercore_machine_type_keyword[k]: k
-                for k in cls._map_ansible_to_hypercore_machine_type_keyword
+                hypercore_value: ansible_value
+                for ansible_value, hypercore_value in cls._map_ansible_to_hypercore_machine_type_keyword.items()
             }
             # "machineTypeKeyword" is available in HyperCore 9.3 or later
             return _map_hypercore_machine_type_keyword_to_ansible.get(

plugins/module_utils/vm_snapshot.py

@@ -38,7 +38,7 @@ def __init__(
         device_snapshots: Optional[List[Dict[Any, Any]]] = None,
         timestamp: Optional[int] = None,
         label: Optional[str] = None,
-        type: Optional[str] = None,
+        snapshot_type: Optional[str] = None,
         automated_trigger_timestamp: Optional[int] = None,
         local_retain_until_timestamp: Optional[float] = None,
         remote_retain_until_timestamp: Optional[float] = None,
@@ -53,7 +53,7 @@ def __init__(
         self.device_snapshots = device_snapshots if device_snapshots is not None else []
         self.timestamp = timestamp
         self.label = label
-        self.type = type
+        self.type = snapshot_type
         self.automated_trigger_timestamp = automated_trigger_timestamp
         self.local_retain_until_timestamp = local_retain_until_timestamp
         self.remote_retain_until_timestamp = remote_retain_until_timestamp
@@ -134,7 +134,7 @@ def from_hypercore(
             ],
             timestamp=hypercore_data["timestamp"],
             label=hypercore_data["label"],
-            type=hypercore_data["type"],
+            snapshot_type=hypercore_data["type"],
             automated_trigger_timestamp=hypercore_data["automatedTriggerTimestamp"],
             local_retain_until_timestamp=hypercore_data["localRetainUntilTimestamp"],
             remote_retain_until_timestamp=hypercore_data["remoteRetainUntilTimestamp"],

plugins/modules/api.py

@@ -251,7 +251,7 @@ def delete_record(module, rest_client):
     return False, dict()
 
 
-"""
+__COMMENT = """
 PUT_TIMEOUT_TIME was copied from the iso module for ISO data upload.
 Currently, assume we have 4.7 GB ISO and speed 1 MB/s -> 4700 seconds.
 Rounded to 3600.

plugins/modules/iso.py

@@ -164,7 +164,7 @@
 from ..module_utils.rest_client import RestClient
 from ..module_utils.task_tag import TaskTag
 
-"""
+__COMMENT = """
 ISO_TIMEOUT_TIME is timeout for ISO data upload.
 Currently, assume we have 4.7 GB ISO and speed 1 MB/s -> 4700 seconds.
 Rounded to 3600.

plugins/modules/oidc_config.py

@@ -128,8 +128,7 @@ def ensure_present(
                 )
                 sleep(1)
                 continue
-            else:
-                raise
+            raise
     # module.warn(f"API during reconfiguration ii={ii}")
 
     for ii in range(max_retries):
@@ -143,8 +142,7 @@ def ensure_present(
                 )
                 sleep(1)
                 continue
-            else:
-                raise
+            raise
     # module.warn(f"API after reconfiguration ii={ii}")
 
     after = updated_oidc.to_ansible() if updated_oidc else None

plugins/modules/version_update_info.py

@@ -199,8 +199,8 @@ def main() -> None:
     try:
         client = Client.get_client(module.params["cluster_instance"])
         rest_client = RestClient(client)
-        records, next, latest = run(rest_client)
-        module.exit_json(changed=False, records=records, next=next, latest=latest)
+        records, next_version, latest_version = run(rest_client)
+        module.exit_json(changed=False, records=records, next=next_version, latest=latest_version)
 
     except errors.ScaleComputingError as e:
         module.fail_json(msg=str(e))

tests/unit/plugins/conftest.py

@@ -90,20 +90,20 @@ def fail_json_mock(self, **result):
     raise AnsibleRunEnd(False, result)
 
 
-def run_mock(module, client, another_client=None):
+def run_mock(module, _client, _another_client=None):
     return False, {}, dict(before={}, after={})
 
 
-def run_mock_with_reboot(module, client, another_client=None):
+def run_mock_with_reboot(module, _client, _another_client=None):
     return False, {}, dict(before={}, after={}), False
 
 
 # for syslog_server module
-def run_mock_with_record_and_records(module, client, another_client=None):
+def run_mock_with_record_and_records(module, _client, _another_client=None):
     return False, {}, [], dict(before={}, after={})
 
 
-def run_mock_info(module, client, another_client=None):
+def run_mock_info(module, _client, _another_client=None):
     return False, []