Reformat everything.

plugins/modules/manageiq_provider.py

@@ -515,45 +515,42 @@ from ansible_collections.community.general.plugins.module_utils.manageiq import
 def supported_providers():
     return dict(
         Openshift=dict(
-            class_name='ManageIQ::Providers::Openshift::ContainerManager',
-            authtype='bearer',
-            default_role='default',
-            metrics_role='prometheus',
-            alerts_role='prometheus_alerts',
+            class_name="ManageIQ::Providers::Openshift::ContainerManager",
+            authtype="bearer",
+            default_role="default",
+            metrics_role="prometheus",
+            alerts_role="prometheus_alerts",
         ),
         Amazon=dict(
-            class_name='ManageIQ::Providers::Amazon::CloudManager',
+            class_name="ManageIQ::Providers::Amazon::CloudManager",
         ),
         oVirt=dict(
-            class_name='ManageIQ::Providers::Redhat::InfraManager',
-            default_role='default',
-            metrics_role='metrics',
+            class_name="ManageIQ::Providers::Redhat::InfraManager",
+            default_role="default",
+            metrics_role="metrics",
         ),
         VMware=dict(
-            class_name='ManageIQ::Providers::Vmware::InfraManager',
+            class_name="ManageIQ::Providers::Vmware::InfraManager",
         ),
         Azure=dict(
-            class_name='ManageIQ::Providers::Azure::CloudManager',
-        ),
-        Director=dict(
-            class_name='ManageIQ::Providers::Openstack::InfraManager',
-            ssh_keypair_role="ssh_keypair"
+            class_name="ManageIQ::Providers::Azure::CloudManager",
         ),
+        Director=dict(class_name="ManageIQ::Providers::Openstack::InfraManager", ssh_keypair_role="ssh_keypair"),
         OpenStack=dict(
-            class_name='ManageIQ::Providers::Openstack::CloudManager',
+            class_name="ManageIQ::Providers::Openstack::CloudManager",
         ),
         GCE=dict(
-            class_name='ManageIQ::Providers::Google::CloudManager',
+            class_name="ManageIQ::Providers::Google::CloudManager",
         ),
     )
 
 
 def endpoint_list_spec():
     return dict(
-        provider=dict(type='dict', options=endpoint_argument_spec()),
-        metrics=dict(type='dict', options=endpoint_argument_spec()),
-        alerts=dict(type='dict', options=endpoint_argument_spec()),
-        ssh_keypair=dict(type='dict', options=endpoint_argument_spec(), no_log=False),
+        provider=dict(type="dict", options=endpoint_argument_spec()),
+        metrics=dict(type="dict", options=endpoint_argument_spec()),
+        alerts=dict(type="dict", options=endpoint_argument_spec()),
+        ssh_keypair=dict(type="dict", options=endpoint_argument_spec(), no_log=False),
     )
 
 
@@ -561,15 +558,15 @@ def endpoint_argument_spec():
     return dict(
         role=dict(),
         hostname=dict(required=True),
-        port=dict(type='int'),
-        validate_certs=dict(default=True, type='bool', aliases=['verify_ssl']),
+        port=dict(type="int"),
+        validate_certs=dict(default=True, type="bool", aliases=["verify_ssl"]),
         certificate_authority=dict(),
         security_protocol=dict(
             choices=[
-                'ssl-with-validation',
-                'ssl-with-validation-custom-ca',
-                'ssl-without-validation',
-                'non-ssl',
+                "ssl-with-validation",
+                "ssl-with-validation-custom-ca",
+                "ssl-without-validation",
+                "non-ssl",
             ],
         ),
         userid=dict(),
@@ -583,7 +580,7 @@ def endpoint_argument_spec():
 
 
 def delete_nulls(h):
-    """ Remove null entries from a hash
+    """Remove null entries from a hash
 
     Returns:
         a hash without nulls
@@ -598,7 +595,7 @@ def delete_nulls(h):
 
 class ManageIQProvider:
     """
-        Object to execute provider management operations in manageiq.
+    Object to execute provider management operations in manageiq.
     """
 
     def __init__(self, manageiq):
@@ -609,40 +606,39 @@ class ManageIQProvider:
         self.client = self.manageiq.client
 
     def class_name_to_type(self, class_name):
-        """ Convert class_name to type
+        """Convert class_name to type
 
         Returns:
             the type
         """
-        out = [k for k, v in supported_providers().items() if v['class_name'] == class_name]
+        out = [k for k, v in supported_providers().items() if v["class_name"] == class_name]
         if len(out) == 1:
             return out[0]
 
         return None
 
     def zone_id(self, name):
-        """ Search for zone id by zone name.
+        """Search for zone id by zone name.
 
         Returns:
             the zone id, or send a module Fail signal if zone not found.
         """
-        zone = self.manageiq.find_collection_resource_by('zones', name=name)
+        zone = self.manageiq.find_collection_resource_by("zones", name=name)
         if not zone:  # zone doesn't exist
-            self.module.fail_json(
-                msg=f"zone {name} does not exist in manageiq")
+            self.module.fail_json(msg=f"zone {name} does not exist in manageiq")
 
-        return zone['id']
+        return zone["id"]
 
     def provider(self, name):
-        """ Search for provider object by name.
+        """Search for provider object by name.
 
         Returns:
             the provider, or None if provider not found.
         """
-        return self.manageiq.find_collection_resource_by('providers', name=name)
+        return self.manageiq.find_collection_resource_by("providers", name=name)
 
     def build_connection_configurations(self, provider_type, endpoints):
-        """ Build "connection_configurations" objects from
+        """Build "connection_configurations" objects from
         requested endpoints provided by user
 
         Returns:
@@ -653,59 +649,74 @@ class ManageIQProvider:
         provider_defaults = supported_providers().get(provider_type, {})
 
         # get endpoint defaults
-        endpoint = endpoints.get('provider')
-        default_auth_key = endpoint.get('auth_key')
+        endpoint = endpoints.get("provider")
+        default_auth_key = endpoint.get("auth_key")
 
         # build a connection_configuration object for each endpoint
         for endpoint_key in endpoint_keys:
             endpoint = endpoints.get(endpoint_key)
             if endpoint:
                 # get role and authtype
-                role = endpoint.get('role') or provider_defaults.get(f"{endpoint_key}_role", 'default')
-                if role == 'default':
-                    authtype = provider_defaults.get('authtype') or role
+                role = endpoint.get("role") or provider_defaults.get(f"{endpoint_key}_role", "default")
+                if role == "default":
+                    authtype = provider_defaults.get("authtype") or role
                 else:
                     authtype = role
 
                 # set a connection_configuration
-                connection_configurations.append({
-                    'endpoint': {
-                        'role': role,
-                        'hostname': endpoint.get('hostname'),
-                        'port': endpoint.get('port'),
-                        'verify_ssl': [0, 1][endpoint.get('validate_certs', True)],
-                        'security_protocol': endpoint.get('security_protocol'),
-                        'certificate_authority': endpoint.get('certificate_authority'),
-                        'path': endpoint.get('path'),
-                    },
-                    'authentication': {
-                        'authtype': authtype,
-                        'userid': endpoint.get('userid'),
-                        'password': endpoint.get('password'),
-                        'auth_key': endpoint.get('auth_key') or default_auth_key,
+                connection_configurations.append(
+                    {
+                        "endpoint": {
+                            "role": role,
+                            "hostname": endpoint.get("hostname"),
+                            "port": endpoint.get("port"),
+                            "verify_ssl": [0, 1][endpoint.get("validate_certs", True)],
+                            "security_protocol": endpoint.get("security_protocol"),
+                            "certificate_authority": endpoint.get("certificate_authority"),
+                            "path": endpoint.get("path"),
+                        },
+                        "authentication": {
+                            "authtype": authtype,
+                            "userid": endpoint.get("userid"),
+                            "password": endpoint.get("password"),
+                            "auth_key": endpoint.get("auth_key") or default_auth_key,
+                        },
                     }
-                })
+                )
 
         return connection_configurations
 
     def delete_provider(self, provider):
-        """ Deletes a provider from manageiq.
+        """Deletes a provider from manageiq.
 
         Returns:
             a short message describing the operation executed.
         """
         try:
             url = f"{self.api_url}/providers/{provider['id']}"
-            result = self.client.post(url, action='delete')
+            result = self.client.post(url, action="delete")
         except Exception as e:
             self.module.fail_json(msg=f"failed to delete provider {provider['name']}: {e}")
 
-        return dict(changed=True, msg=result['message'])
+        return dict(changed=True, msg=result["message"])
 
-    def edit_provider(self, provider, name, provider_type, endpoints, zone_id, provider_region,
-                      host_default_vnc_port_start, host_default_vnc_port_end,
-                      subscription, project, uid_ems, tenant_mapping_enabled, api_version):
-        """ Edit a provider from manageiq.
+    def edit_provider(
+        self,
+        provider,
+        name,
+        provider_type,
+        endpoints,
+        zone_id,
+        provider_region,
+        host_default_vnc_port_start,
+        host_default_vnc_port_end,
+        subscription,
+        project,
+        uid_ems,
+        tenant_mapping_enabled,
+        api_version,
+    ):
+        """Edit a provider from manageiq.
 
         Returns:
             a short message describing the operation executed.
@@ -714,7 +725,7 @@ class ManageIQProvider:
 
         resource = dict(
             name=name,
-            zone={'id': zone_id},
+            zone={"id": zone_id},
             provider_region=provider_region,
             connection_configurations=endpoints,
             host_default_vnc_port_start=host_default_vnc_port_start,
@@ -737,25 +748,35 @@ class ManageIQProvider:
 
         # try to update provider
         try:
-            result = self.client.post(url, action='edit', resource=resource)
+            result = self.client.post(url, action="edit", resource=resource)
         except Exception as e:
             self.module.fail_json(msg=f"failed to update provider {provider['name']}: {e}")
 
-        return dict(
-            changed=True,
-            msg=f"successfully updated the provider {provider['name']}: {result}")
+        return dict(changed=True, msg=f"successfully updated the provider {provider['name']}: {result}")
 
-    def create_provider(self, name, provider_type, endpoints, zone_id, provider_region,
-                        host_default_vnc_port_start, host_default_vnc_port_end,
-                        subscription, project, uid_ems, tenant_mapping_enabled, api_version):
-        """ Creates the provider in manageiq.
+    def create_provider(
+        self,
+        name,
+        provider_type,
+        endpoints,
+        zone_id,
+        provider_region,
+        host_default_vnc_port_start,
+        host_default_vnc_port_end,
+        subscription,
+        project,
+        uid_ems,
+        tenant_mapping_enabled,
+        api_version,
+    ):
+        """Creates the provider in manageiq.
 
         Returns:
             a short message describing the operation executed.
         """
         resource = dict(
             name=name,
-            zone={'id': zone_id},
+            zone={"id": zone_id},
             provider_region=provider_region,
             host_default_vnc_port_start=host_default_vnc_port_start,
             host_default_vnc_port_end=host_default_vnc_port_end,
@@ -772,47 +793,43 @@ class ManageIQProvider:
 
         # try to create a new provider
         try:
-            url = f'{self.api_url}/providers'
-            result = self.client.post(url, type=supported_providers()[provider_type]['class_name'], **resource)
+            url = f"{self.api_url}/providers"
+            result = self.client.post(url, type=supported_providers()[provider_type]["class_name"], **resource)
         except Exception as e:
             self.module.fail_json(msg=f"failed to create provider {name}: {e}")
 
-        return dict(
-            changed=True,
-            msg=f"successfully created the provider {name}: {result['results']}")
+        return dict(changed=True, msg=f"successfully created the provider {name}: {result['results']}")
 
     def refresh(self, provider, name):
-        """ Trigger provider refresh.
+        """Trigger provider refresh.
 
         Returns:
             a short message describing the operation executed.
         """
         try:
             url = f"{self.api_url}/providers/{provider['id']}"
-            result = self.client.post(url, action='refresh')
+            result = self.client.post(url, action="refresh")
         except Exception as e:
             self.module.fail_json(msg=f"failed to refresh provider {name}: {e}")
 
-        return dict(
-            changed=True,
-            msg=f"refreshing provider {name}")
+        return dict(changed=True, msg=f"refreshing provider {name}")
 
 
 def main():
     zone_id = None
     endpoints = []
     argument_spec = dict(
-        state=dict(choices=['absent', 'present', 'refresh'], default='present'),
+        state=dict(choices=["absent", "present", "refresh"], default="present"),
         name=dict(required=True),
-        zone=dict(default='default'),
+        zone=dict(default="default"),
         provider_region=dict(),
         host_default_vnc_port_start=dict(),
         host_default_vnc_port_end=dict(),
         subscription=dict(),
         project=dict(),
-        azure_tenant_id=dict(aliases=['keystone_v3_domain_id']),
-        tenant_mapping_enabled=dict(default=False, type='bool'),
-        api_version=dict(choices=['v2', 'v3']),
+        azure_tenant_id=dict(aliases=["keystone_v3_domain_id"]),
+        tenant_mapping_enabled=dict(default=False, type="bool"),
+        api_version=dict(choices=["v2", "v3"]),
         type=dict(choices=list(supported_providers().keys())),
     )
     # add the manageiq connection arguments to the arguments
@@ -822,27 +839,23 @@ def main():
 
     module = AnsibleModule(
         argument_spec=argument_spec,
-        required_if=[
-            ('state', 'present', ['provider']),
-            ('state', 'refresh', ['name'])],
-        required_together=[
-            ['host_default_vnc_port_start', 'host_default_vnc_port_end']
-        ],
+        required_if=[("state", "present", ["provider"]), ("state", "refresh", ["name"])],
+        required_together=[["host_default_vnc_port_start", "host_default_vnc_port_end"]],
     )
 
-    name = module.params['name']
-    zone_name = module.params['zone']
-    provider_type = module.params['type']
+    name = module.params["name"]
+    zone_name = module.params["zone"]
+    provider_type = module.params["type"]
     raw_endpoints = module.params
-    provider_region = module.params['provider_region']
-    host_default_vnc_port_start = module.params['host_default_vnc_port_start']
-    host_default_vnc_port_end = module.params['host_default_vnc_port_end']
-    subscription = module.params['subscription']
-    uid_ems = module.params['azure_tenant_id']
-    project = module.params['project']
-    tenant_mapping_enabled = module.params['tenant_mapping_enabled']
-    api_version = module.params['api_version']
-    state = module.params['state']
+    provider_region = module.params["provider_region"]
+    host_default_vnc_port_start = module.params["host_default_vnc_port_start"]
+    host_default_vnc_port_end = module.params["host_default_vnc_port_end"]
+    subscription = module.params["subscription"]
+    uid_ems = module.params["azure_tenant_id"]
+    project = module.params["project"]
+    tenant_mapping_enabled = module.params["tenant_mapping_enabled"]
+    api_version = module.params["api_version"]
+    state = module.params["state"]
 
     manageiq = ManageIQ(module)
     manageiq_provider = ManageIQProvider(manageiq)
@@ -856,9 +869,7 @@ def main():
             res_args = manageiq_provider.delete_provider(provider)
         # if we do not have a provider, nothing to do
         else:
-            res_args = dict(
-                changed=False,
-                msg=f"provider {name}: does not exist in manageiq")
+            res_args = dict(changed=False, msg=f"provider {name}: does not exist in manageiq")
 
     # provider should exist
     if state == "present":
@@ -868,17 +879,15 @@ def main():
 
         # if we do not have a provider_type, use the current provider_type
         if provider and not provider_type:
-            provider_type = manageiq_provider.class_name_to_type(provider['type'])
+            provider_type = manageiq_provider.class_name_to_type(provider["type"])
 
         # check supported_providers types
         if not provider_type:
-            manageiq_provider.module.fail_json(
-                msg="missing required argument: provider_type")
+            manageiq_provider.module.fail_json(msg="missing required argument: provider_type")
 
         # check supported_providers types
         if provider_type not in supported_providers().keys():
-            manageiq_provider.module.fail_json(
-                msg=f"provider_type {provider_type} is not supported")
+            manageiq_provider.module.fail_json(msg=f"provider_type {provider_type} is not supported")
 
         # build "connection_configurations" objects from user requested endpoints
         # "provider" is a required endpoint, if we have it, we have endpoints
@@ -887,23 +896,44 @@ def main():
 
         # if we have a provider, edit it
         if provider:
-            res_args = manageiq_provider.edit_provider(provider, name, provider_type, endpoints, zone_id, provider_region,
-                                                       host_default_vnc_port_start, host_default_vnc_port_end,
-                                                       subscription, project, uid_ems, tenant_mapping_enabled, api_version)
+            res_args = manageiq_provider.edit_provider(
+                provider,
+                name,
+                provider_type,
+                endpoints,
+                zone_id,
+                provider_region,
+                host_default_vnc_port_start,
+                host_default_vnc_port_end,
+                subscription,
+                project,
+                uid_ems,
+                tenant_mapping_enabled,
+                api_version,
+            )
         # if we do not have a provider, create it
         else:
-            res_args = manageiq_provider.create_provider(name, provider_type, endpoints, zone_id, provider_region,
-                                                         host_default_vnc_port_start, host_default_vnc_port_end,
-                                                         subscription, project, uid_ems, tenant_mapping_enabled, api_version)
+            res_args = manageiq_provider.create_provider(
+                name,
+                provider_type,
+                endpoints,
+                zone_id,
+                provider_region,
+                host_default_vnc_port_start,
+                host_default_vnc_port_end,
+                subscription,
+                project,
+                uid_ems,
+                tenant_mapping_enabled,
+                api_version,
+            )
 
     # refresh provider (trigger sync)
     if state == "refresh":
         if provider:
             res_args = manageiq_provider.refresh(provider, name)
         else:
-            res_args = dict(
-                changed=False,
-                msg=f"provider {name}: does not exist in manageiq")
+            res_args = dict(changed=False, msg=f"provider {name}: does not exist in manageiq")
 
     module.exit_json(**res_args)