move code linting to a stricter pep8-esque auto-formatting tool, black

awx/main/analytics/broadcast_websocket.py

@@ -24,7 +24,7 @@ logger = logging.getLogger('awx.analytics.broadcast_websocket')
 
 
 def dt_to_seconds(dt):
-    return int((dt - datetime.datetime(1970,1,1)).total_seconds())
+    return int((dt - datetime.datetime(1970, 1, 1)).total_seconds())
 
 
 def now_seconds():
@@ -37,7 +37,7 @@ def safe_name(s):
 
 
 # Second granularity; Per-minute
-class FixedSlidingWindow():
+class FixedSlidingWindow:
     def __init__(self, start_time=None):
         self.buckets = dict()
         self.start_time = start_time or now_seconds()
@@ -65,7 +65,7 @@ class FixedSlidingWindow():
         return sum(self.buckets.values()) or 0
 
 
-class BroadcastWebsocketStatsManager():
+class BroadcastWebsocketStatsManager:
     def __init__(self, event_loop, local_hostname):
         self._local_hostname = local_hostname
 
@@ -74,8 +74,7 @@ class BroadcastWebsocketStatsManager():
         self._redis_key = BROADCAST_WEBSOCKET_REDIS_KEY_NAME
 
     def new_remote_host_stats(self, remote_hostname):
-        self._stats[remote_hostname] = BroadcastWebsocketStats(self._local_hostname,
-                                                               remote_hostname)
+        self._stats[remote_hostname] = BroadcastWebsocketStats(self._local_hostname, remote_hostname)
         return self._stats[remote_hostname]
 
     def delete_remote_host_stats(self, remote_hostname):
@@ -100,15 +99,15 @@ class BroadcastWebsocketStatsManager():
 
     @classmethod
     def get_stats_sync(cls):
-        '''
+        """
         Stringified verion of all the stats
-        '''
+        """
         redis_conn = redis.Redis.from_url(settings.BROKER_URL)
         stats_str = redis_conn.get(BROADCAST_WEBSOCKET_REDIS_KEY_NAME) or b''
         return parser.text_string_to_metric_families(stats_str.decode('UTF-8'))
 
 
-class BroadcastWebsocketStats():
+class BroadcastWebsocketStats:
     def __init__(self, local_hostname, remote_hostname):
         self._local_hostname = local_hostname
         self._remote_hostname = remote_hostname
@@ -118,24 +117,25 @@ class BroadcastWebsocketStats():
         self.name = safe_name(self._local_hostname)
         self.remote_name = safe_name(self._remote_hostname)
 
-        self._messages_received_total = Counter(f'awx_{self.remote_name}_messages_received_total',
-                                                'Number of messages received, to be forwarded, by the broadcast websocket system',
-                                                registry=self._registry)
-        self._messages_received = Gauge(f'awx_{self.remote_name}_messages_received',
-                                        'Number forwarded messages received by the broadcast websocket system, for the duration of the current connection',
-                                        registry=self._registry)
-        self._connection = Enum(f'awx_{self.remote_name}_connection',
-                                'Websocket broadcast connection',
-                                states=['disconnected', 'connected'],
-                                registry=self._registry)
+        self._messages_received_total = Counter(
+            f'awx_{self.remote_name}_messages_received_total',
+            'Number of messages received, to be forwarded, by the broadcast websocket system',
+            registry=self._registry,
+        )
+        self._messages_received = Gauge(
+            f'awx_{self.remote_name}_messages_received',
+            'Number forwarded messages received by the broadcast websocket system, for the duration of the current connection',
+            registry=self._registry,
+        )
+        self._connection = Enum(
+            f'awx_{self.remote_name}_connection', 'Websocket broadcast connection', states=['disconnected', 'connected'], registry=self._registry
+        )
         self._connection.state('disconnected')
-        self._connection_start = Gauge(f'awx_{self.remote_name}_connection_start',
-                                       'Time the connection was established',
-                                       registry=self._registry)
+        self._connection_start = Gauge(f'awx_{self.remote_name}_connection_start', 'Time the connection was established', registry=self._registry)
 
-        self._messages_received_per_minute = Gauge(f'awx_{self.remote_name}_messages_received_per_minute',
-                                                   'Messages received per minute',
-                                                   registry=self._registry)
+        self._messages_received_per_minute = Gauge(
+            f'awx_{self.remote_name}_messages_received_per_minute', 'Messages received per minute', registry=self._registry
+        )
         self._internal_messages_received_per_minute = FixedSlidingWindow()
 
     def unregister(self):

awx/main/analytics/collectors.py

@@ -10,8 +10,7 @@ from django.utils.timezone import now
 from django.utils.translation import ugettext_lazy as _
 
 from awx.conf.license import get_license
-from awx.main.utils import (get_awx_version, get_ansible_version,
-                            get_custom_venv_choices, camelcase_to_underscore)
+from awx.main.utils import get_awx_version, get_ansible_version, get_custom_venv_choices, camelcase_to_underscore
 from awx.main import models
 from django.contrib.sessions.models import Session
 from awx.main.analytics import register
@@ -68,96 +67,99 @@ def config(since, **kwargs):
 @register('counts', '1.0', description=_('Counts of objects such as organizations, inventories, and projects'))
 def counts(since, **kwargs):
     counts = {}
-    for cls in (models.Organization, models.Team, models.User,
-                models.Inventory, models.Credential, models.Project,
-                models.JobTemplate, models.WorkflowJobTemplate, 
-                models.Host, models.Schedule, models.CustomInventoryScript, 
-                models.NotificationTemplate):
+    for cls in (
+        models.Organization,
+        models.Team,
+        models.User,
+        models.Inventory,
+        models.Credential,
+        models.Project,
+        models.JobTemplate,
+        models.WorkflowJobTemplate,
+        models.Host,
+        models.Schedule,
+        models.CustomInventoryScript,
+        models.NotificationTemplate,
+    ):
         counts[camelcase_to_underscore(cls.__name__)] = cls.objects.count()
 
     venvs = get_custom_venv_choices()
-    counts['custom_virtualenvs'] = len([
-        v for v in venvs
-        if os.path.basename(v.rstrip('/')) != 'ansible'
-    ])
+    counts['custom_virtualenvs'] = len([v for v in venvs if os.path.basename(v.rstrip('/')) != 'ansible'])
 
     inv_counts = dict(models.Inventory.objects.order_by().values_list('kind').annotate(Count('kind')))
     inv_counts['normal'] = inv_counts.get('', 0)
     inv_counts.pop('', None)
     inv_counts['smart'] = inv_counts.get('smart', 0)
     counts['inventories'] = inv_counts
-    
-    counts['unified_job'] = models.UnifiedJob.objects.exclude(launch_type='sync').count() # excludes implicit project_updates
-    counts['active_host_count'] = models.Host.objects.active_count()   
+
+    counts['unified_job'] = models.UnifiedJob.objects.exclude(launch_type='sync').count()  # excludes implicit project_updates
+    counts['active_host_count'] = models.Host.objects.active_count()
     active_sessions = Session.objects.filter(expire_date__gte=now()).count()
     active_user_sessions = models.UserSessionMembership.objects.select_related('session').filter(session__expire_date__gte=now()).count()
     active_anonymous_sessions = active_sessions - active_user_sessions
     counts['active_sessions'] = active_sessions
     counts['active_user_sessions'] = active_user_sessions
     counts['active_anonymous_sessions'] = active_anonymous_sessions
-    counts['running_jobs'] = models.UnifiedJob.objects.exclude(launch_type='sync').filter(status__in=('running', 'waiting',)).count()
+    counts['running_jobs'] = (
+        models.UnifiedJob.objects.exclude(launch_type='sync')
+        .filter(
+            status__in=(
+                'running',
+                'waiting',
+            )
+        )
+        .count()
+    )
     counts['pending_jobs'] = models.UnifiedJob.objects.exclude(launch_type='sync').filter(status__in=('pending',)).count()
     return counts
 
-    
+
 @register('org_counts', '1.0', description=_('Counts of users and teams by organization'))
 def org_counts(since, **kwargs):
     counts = {}
-    for org in models.Organization.objects.annotate(num_users=Count('member_role__members', distinct=True), 
-                                                    num_teams=Count('teams', distinct=True)).values('name', 'id', 'num_users', 'num_teams'):
-        counts[org['id']] = {'name': org['name'],
-                             'users': org['num_users'],
-                             'teams': org['num_teams']
-                             }
+    for org in models.Organization.objects.annotate(num_users=Count('member_role__members', distinct=True), num_teams=Count('teams', distinct=True)).values(
+        'name', 'id', 'num_users', 'num_teams'
+    ):
+        counts[org['id']] = {'name': org['name'], 'users': org['num_users'], 'teams': org['num_teams']}
     return counts
-    
-    
+
+
 @register('cred_type_counts', '1.0', description=_('Counts of credentials by credential type'))
 def cred_type_counts(since, **kwargs):
     counts = {}
-    for cred_type in models.CredentialType.objects.annotate(num_credentials=Count(
-                                                            'credentials', distinct=True)).values('name', 'id', 'managed_by_tower', 'num_credentials'):  
-        counts[cred_type['id']] = {'name': cred_type['name'],
-                                   'credential_count': cred_type['num_credentials'],
-                                   'managed_by_tower': cred_type['managed_by_tower']
-                                   }
+    for cred_type in models.CredentialType.objects.annotate(num_credentials=Count('credentials', distinct=True)).values(
+        'name', 'id', 'managed_by_tower', 'num_credentials'
+    ):
+        counts[cred_type['id']] = {
+            'name': cred_type['name'],
+            'credential_count': cred_type['num_credentials'],
+            'managed_by_tower': cred_type['managed_by_tower'],
+        }
     return counts
-    
-    
+
+
 @register('inventory_counts', '1.2', description=_('Inventories, their inventory sources, and host counts'))
 def inventory_counts(since, **kwargs):
     counts = {}
-    for inv in models.Inventory.objects.filter(kind='').annotate(num_sources=Count('inventory_sources', distinct=True), 
-                                                                 num_hosts=Count('hosts', distinct=True)).only('id', 'name', 'kind'):
+    for inv in (
+        models.Inventory.objects.filter(kind='')
+        .annotate(num_sources=Count('inventory_sources', distinct=True), num_hosts=Count('hosts', distinct=True))
+        .only('id', 'name', 'kind')
+    ):
         source_list = []
-        for source in inv.inventory_sources.filter().annotate(num_hosts=Count('hosts', distinct=True)).values('name','source', 'num_hosts'):
+        for source in inv.inventory_sources.filter().annotate(num_hosts=Count('hosts', distinct=True)).values('name', 'source', 'num_hosts'):
             source_list.append(source)
-        counts[inv.id] = {'name': inv.name,
-                          'kind': inv.kind,
-                          'hosts': inv.num_hosts,
-                          'sources': inv.num_sources,
-                          'source_list': source_list
-                          }
+        counts[inv.id] = {'name': inv.name, 'kind': inv.kind, 'hosts': inv.num_hosts, 'sources': inv.num_sources, 'source_list': source_list}
 
     for smart_inv in models.Inventory.objects.filter(kind='smart'):
-        counts[smart_inv.id] = {'name': smart_inv.name,
-                                'kind': smart_inv.kind,
-                                'hosts': smart_inv.hosts.count(),
-                                'sources': 0,
-                                'source_list': []
-                                }
+        counts[smart_inv.id] = {'name': smart_inv.name, 'kind': smart_inv.kind, 'hosts': smart_inv.hosts.count(), 'sources': 0, 'source_list': []}
     return counts
 
 
 @register('projects_by_scm_type', '1.0', description=_('Counts of projects by source control type'))
 def projects_by_scm_type(since, **kwargs):
-    counts = dict(
-        (t[0] or 'manual', 0)
-        for t in models.Project.SCM_TYPE_CHOICES
-    )
-    for result in models.Project.objects.values('scm_type').annotate(
-        count=Count('scm_type')
-    ).order_by('scm_type'):
+    counts = dict((t[0] or 'manual', 0) for t in models.Project.SCM_TYPE_CHOICES)
+    for result in models.Project.objects.values('scm_type').annotate(count=Count('scm_type')).order_by('scm_type'):
         counts[result['scm_type'] or 'manual'] = result['count']
     return counts
 
@@ -172,10 +174,10 @@ def _get_isolated_datetime(last_check):
 def instance_info(since, include_hostnames=False, **kwargs):
     info = {}
     instances = models.Instance.objects.values_list('hostname').values(
-        'uuid', 'version', 'capacity', 'cpu', 'memory', 'managed_by_policy', 'hostname', 'last_isolated_check', 'enabled')
+        'uuid', 'version', 'capacity', 'cpu', 'memory', 'managed_by_policy', 'hostname', 'last_isolated_check', 'enabled'
+    )
     for instance in instances:
-        consumed_capacity = sum(x.task_impact for x in models.UnifiedJob.objects.filter(execution_node=instance['hostname'],
-                                status__in=('running', 'waiting')))
+        consumed_capacity = sum(x.task_impact for x in models.UnifiedJob.objects.filter(execution_node=instance['hostname'], status__in=('running', 'waiting')))
         instance_info = {
             'uuid': instance['uuid'],
             'version': instance['version'],
@@ -186,7 +188,7 @@ def instance_info(since, include_hostnames=False, **kwargs):
             'last_isolated_check': _get_isolated_datetime(instance['last_isolated_check']),
             'enabled': instance['enabled'],
             'consumed_capacity': consumed_capacity,
-            'remaining_capacity': instance['capacity'] - consumed_capacity
+            'remaining_capacity': instance['capacity'] - consumed_capacity,
         }
         if include_hostnames is True:
             instance_info['hostname'] = instance['hostname']
@@ -198,20 +200,22 @@ def job_counts(since, **kwargs):
     counts = {}
     counts['total_jobs'] = models.UnifiedJob.objects.exclude(launch_type='sync').count()
     counts['status'] = dict(models.UnifiedJob.objects.exclude(launch_type='sync').values_list('status').annotate(Count('status')).order_by())
-    counts['launch_type'] = dict(models.UnifiedJob.objects.exclude(launch_type='sync').values_list(
-        'launch_type').annotate(Count('launch_type')).order_by())
+    counts['launch_type'] = dict(models.UnifiedJob.objects.exclude(launch_type='sync').values_list('launch_type').annotate(Count('launch_type')).order_by())
     return counts
-    
-    
+
+
 def job_instance_counts(since, **kwargs):
     counts = {}
-    job_types = models.UnifiedJob.objects.exclude(launch_type='sync').values_list(
-        'execution_node', 'launch_type').annotate(job_launch_type=Count('launch_type')).order_by()
+    job_types = (
+        models.UnifiedJob.objects.exclude(launch_type='sync')
+        .values_list('execution_node', 'launch_type')
+        .annotate(job_launch_type=Count('launch_type'))
+        .order_by()
+    )
     for job in job_types:
         counts.setdefault(job[0], {}).setdefault('launch_type', {})[job[1]] = job[2]
-        
-    job_statuses = models.UnifiedJob.objects.exclude(launch_type='sync').values_list(
-        'execution_node', 'status').annotate(job_status=Count('status')).order_by()
+
+    job_statuses = models.UnifiedJob.objects.exclude(launch_type='sync').values_list('execution_node', 'status').annotate(job_status=Count('status')).order_by()
     for job in job_statuses:
         counts.setdefault(job[0], {}).setdefault('status', {})[job[1]] = job[2]
     return counts
@@ -261,12 +265,12 @@ class FileSplitter(io.StringIO):
             self.files = self.files[:-1]
         # If we only have one file, remove the suffix
         if len(self.files) == 1:
-            os.rename(self.files[0],self.files[0].replace('_split0',''))
+            os.rename(self.files[0], self.files[0].replace('_split0', ''))
         return self.files
 
     def write(self, s):
         if not self.header:
-            self.header = s[0:s.index('\n')]
+            self.header = s[0 : s.index('\n')]
         self.counter += self.currentfile.write(s)
         if self.counter >= MAX_TABLE_SIZE:
             self.cycle_file()
@@ -307,7 +311,9 @@ def events_table(since, full_path, until, **kwargs):
                               FROM main_jobevent 
                               WHERE (main_jobevent.created > '{}' AND main_jobevent.created <= '{}')
                               ORDER BY main_jobevent.id ASC) TO STDOUT WITH CSV HEADER
-                   '''.format(since.isoformat(),until.isoformat())
+                   '''.format(
+        since.isoformat(), until.isoformat()
+    )
     return _copy_table(table='events', query=events_query, path=full_path)
 
 
@@ -346,7 +352,9 @@ def unified_jobs_table(since, full_path, until, **kwargs):
                                        OR (main_unifiedjob.finished > '{0}' AND main_unifiedjob.finished <= '{1}'))
                                        AND main_unifiedjob.launch_type != 'sync'
                                  ORDER BY main_unifiedjob.id ASC) TO STDOUT WITH CSV HEADER
-                        '''.format(since.isoformat(),until.isoformat())
+                        '''.format(
+        since.isoformat(), until.isoformat()
+    )
     return _copy_table(table='unified_jobs', query=unified_job_query, path=full_path)
 
 
@@ -369,7 +377,7 @@ def unified_job_template_table(since, full_path, **kwargs):
                                  main_unifiedjobtemplate.status 
                                  FROM main_unifiedjobtemplate, django_content_type
                                  WHERE main_unifiedjobtemplate.polymorphic_ctype_id = django_content_type.id
-                                 ORDER BY main_unifiedjobtemplate.id ASC) TO STDOUT WITH CSV HEADER'''  
+                                 ORDER BY main_unifiedjobtemplate.id ASC) TO STDOUT WITH CSV HEADER'''
     return _copy_table(table='unified_job_template', query=unified_job_template_query, path=full_path)
 
 
@@ -405,7 +413,9 @@ def workflow_job_node_table(since, full_path, until, **kwargs):
                                  ) always_nodes ON main_workflowjobnode.id = always_nodes.from_workflowjobnode_id
                                  WHERE (main_workflowjobnode.modified > '{}' AND main_workflowjobnode.modified <= '{}')
                                  ORDER BY main_workflowjobnode.id ASC) TO STDOUT WITH CSV HEADER
-                              '''.format(since.isoformat(),until.isoformat())
+                              '''.format(
+        since.isoformat(), until.isoformat()
+    )
     return _copy_table(table='workflow_job_node', query=workflow_job_node_query, path=full_path)
 
 
@@ -437,5 +447,5 @@ def workflow_job_template_node_table(since, full_path, **kwargs):
                                      FROM main_workflowjobtemplatenode_always_nodes
                                      GROUP BY from_workflowjobtemplatenode_id
                                  ) always_nodes ON main_workflowjobtemplatenode.id = always_nodes.from_workflowjobtemplatenode_id
-                                 ORDER BY main_workflowjobtemplatenode.id ASC) TO STDOUT WITH CSV HEADER'''   
+                                 ORDER BY main_workflowjobtemplatenode.id ASC) TO STDOUT WITH CSV HEADER'''
     return _copy_table(table='workflow_job_template_node', query=workflow_job_template_node_query, path=full_path)

awx/main/analytics/core.py

@@ -43,7 +43,7 @@ def all_collectors():
             key = func.__awx_analytics_key__
             desc = func.__awx_analytics_description__ or ''
             version = func.__awx_analytics_version__
-            collector_dict[key] = { 'name': key, 'version': version, 'description': desc}
+            collector_dict[key] = {'name': key, 'version': version, 'description': desc}
     return collector_dict
 
 
@@ -82,7 +82,7 @@ def register(key, version, description=None, format='json', expensive=False):
     return decorate
 
 
-def gather(dest=None, module=None, subset = None, since = None, until = now(), collection_type='scheduled'):
+def gather(dest=None, module=None, subset=None, since=None, until=now(), collection_type='scheduled'):
     """
     Gather all defined metrics and write them as JSON files in a .tgz
 
@@ -90,6 +90,7 @@ def gather(dest=None, module=None, subset = None, since = None, until = now(), c
     :param module: the module to search for registered analytic collector
                     functions; defaults to awx.main.analytics.collectors
     """
+
     def _write_manifest(destdir, manifest):
         path = os.path.join(destdir, 'manifest.json')
         with open(path, 'w', encoding='utf-8') as f:
@@ -116,13 +117,10 @@ def gather(dest=None, module=None, subset = None, since = None, until = now(), c
         collector_module = module
     else:
         from awx.main.analytics import collectors
+
         collector_module = collectors
     for name, func in inspect.getmembers(collector_module):
-        if (
-            inspect.isfunction(func) and
-            hasattr(func, '__awx_analytics_key__') and
-            (not subset or name in subset)
-        ):
+        if inspect.isfunction(func) and hasattr(func, '__awx_analytics_key__') and (not subset or name in subset):
             collector_list.append((name, func))
 
     manifest = dict()
@@ -162,6 +160,7 @@ def gather(dest=None, module=None, subset = None, since = None, until = now(), c
     # Always include config.json if we're using our collectors
     if 'config.json' not in manifest.keys() and not module:
         from awx.main.analytics import collectors
+
         config = collectors.config
         path = '{}.json'.format(os.path.join(gather_dir, config.__awx_analytics_key__))
         with open(path, 'w', encoding='utf-8') as f:
@@ -204,22 +203,14 @@ def gather(dest=None, module=None, subset = None, since = None, until = now(), c
         for i in range(0, len(stage_dirs)):
             stage_dir = stage_dirs[i]
             # can't use isoformat() since it has colons, which GNU tar doesn't like
-            tarname = '_'.join([
-                settings.SYSTEM_UUID,
-                until.strftime('%Y-%m-%d-%H%M%S%z'),
-                str(i)
-            ])
-            tgz = shutil.make_archive(
-                os.path.join(os.path.dirname(dest), tarname),
-                'gztar',
-                stage_dir
-            )
+            tarname = '_'.join([settings.SYSTEM_UUID, until.strftime('%Y-%m-%d-%H%M%S%z'), str(i)])
+            tgz = shutil.make_archive(os.path.join(os.path.dirname(dest), tarname), 'gztar', stage_dir)
             tarfiles.append(tgz)
     except Exception:
-        shutil.rmtree(stage_dir, ignore_errors = True)
+        shutil.rmtree(stage_dir, ignore_errors=True)
         logger.exception("Failed to write analytics archive file")
     finally:
-        shutil.rmtree(dest, ignore_errors = True)
+        shutil.rmtree(dest, ignore_errors=True)
     return tarfiles
 
 
@@ -253,16 +244,17 @@ def ship(path):
             s.headers = get_awx_http_client_headers()
             s.headers.pop('Content-Type')
             with set_environ(**settings.AWX_TASK_ENV):
-                response = s.post(url,
-                                  files=files,
-                                  verify="/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem",
-                                  auth=(rh_user, rh_password),
-                                  headers=s.headers,
-                                  timeout=(31, 31))
+                response = s.post(
+                    url,
+                    files=files,
+                    verify="/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem",
+                    auth=(rh_user, rh_password),
+                    headers=s.headers,
+                    timeout=(31, 31),
+                )
             # Accept 2XX status_codes
             if response.status_code >= 300:
-                return logger.exception('Upload failed with status {}, {}'.format(response.status_code,
-                                                                                  response.text))
+                return logger.exception('Upload failed with status {}, {}'.format(response.status_code, response.text))
     finally:
         # cleanup tar.gz
         if os.path.exists(path):

awx/main/analytics/metrics.py

@@ -1,16 +1,8 @@
 from django.conf import settings
-from prometheus_client import (
-    REGISTRY,
-    PROCESS_COLLECTOR,
-    PLATFORM_COLLECTOR,
-    GC_COLLECTOR,
-    Gauge,
-    Info,
-    generate_latest
-)
+from prometheus_client import REGISTRY, PROCESS_COLLECTOR, PLATFORM_COLLECTOR, GC_COLLECTOR, Gauge, Info, generate_latest
 
 from awx.conf.license import get_license
-from awx.main.utils import (get_awx_version, get_ansible_version)
+from awx.main.utils import get_awx_version, get_ansible_version
 from awx.main.analytics.collectors import (
     counts,
     instance_info,
@@ -31,23 +23,97 @@ INV_COUNT = Gauge('awx_inventories_total', 'Number of inventories')
 PROJ_COUNT = Gauge('awx_projects_total', 'Number of projects')
 JT_COUNT = Gauge('awx_job_templates_total', 'Number of job templates')
 WFJT_COUNT = Gauge('awx_workflow_job_templates_total', 'Number of workflow job templates')
-HOST_COUNT = Gauge('awx_hosts_total', 'Number of hosts', ['type',])
+HOST_COUNT = Gauge(
+    'awx_hosts_total',
+    'Number of hosts',
+    [
+        'type',
+    ],
+)
 SCHEDULE_COUNT = Gauge('awx_schedules_total', 'Number of schedules')
 INV_SCRIPT_COUNT = Gauge('awx_inventory_scripts_total', 'Number of invetory scripts')
-USER_SESSIONS = Gauge('awx_sessions_total', 'Number of sessions', ['type',])
+USER_SESSIONS = Gauge(
+    'awx_sessions_total',
+    'Number of sessions',
+    [
+        'type',
+    ],
+)
 CUSTOM_VENVS = Gauge('awx_custom_virtualenvs_total', 'Number of virtualenvs')
 RUNNING_JOBS = Gauge('awx_running_jobs_total', 'Number of running jobs on the Tower system')
 PENDING_JOBS = Gauge('awx_pending_jobs_total', 'Number of pending jobs on the Tower system')
-STATUS = Gauge('awx_status_total', 'Status of Job launched', ['status',])
+STATUS = Gauge(
+    'awx_status_total',
+    'Status of Job launched',
+    [
+        'status',
+    ],
+)
 
-INSTANCE_CAPACITY = Gauge('awx_instance_capacity', 'Capacity of each node in a Tower system', ['hostname', 'instance_uuid',])
-INSTANCE_CPU = Gauge('awx_instance_cpu', 'CPU cores on each node in a Tower system', ['hostname', 'instance_uuid',])
-INSTANCE_MEMORY = Gauge('awx_instance_memory', 'RAM (Kb) on each node in a Tower system', ['hostname', 'instance_uuid',])
-INSTANCE_INFO = Info('awx_instance', 'Info about each node in a Tower system', ['hostname', 'instance_uuid',])
-INSTANCE_LAUNCH_TYPE = Gauge('awx_instance_launch_type_total', 'Type of Job launched', ['node', 'launch_type',])
-INSTANCE_STATUS = Gauge('awx_instance_status_total', 'Status of Job launched', ['node', 'status',])
-INSTANCE_CONSUMED_CAPACITY = Gauge('awx_instance_consumed_capacity', 'Consumed capacity of each node in a Tower system', ['hostname', 'instance_uuid',])
-INSTANCE_REMAINING_CAPACITY = Gauge('awx_instance_remaining_capacity', 'Remaining capacity of each node in a Tower system', ['hostname', 'instance_uuid',])
+INSTANCE_CAPACITY = Gauge(
+    'awx_instance_capacity',
+    'Capacity of each node in a Tower system',
+    [
+        'hostname',
+        'instance_uuid',
+    ],
+)
+INSTANCE_CPU = Gauge(
+    'awx_instance_cpu',
+    'CPU cores on each node in a Tower system',
+    [
+        'hostname',
+        'instance_uuid',
+    ],
+)
+INSTANCE_MEMORY = Gauge(
+    'awx_instance_memory',
+    'RAM (Kb) on each node in a Tower system',
+    [
+        'hostname',
+        'instance_uuid',
+    ],
+)
+INSTANCE_INFO = Info(
+    'awx_instance',
+    'Info about each node in a Tower system',
+    [
+        'hostname',
+        'instance_uuid',
+    ],
+)
+INSTANCE_LAUNCH_TYPE = Gauge(
+    'awx_instance_launch_type_total',
+    'Type of Job launched',
+    [
+        'node',
+        'launch_type',
+    ],
+)
+INSTANCE_STATUS = Gauge(
+    'awx_instance_status_total',
+    'Status of Job launched',
+    [
+        'node',
+        'status',
+    ],
+)
+INSTANCE_CONSUMED_CAPACITY = Gauge(
+    'awx_instance_consumed_capacity',
+    'Consumed capacity of each node in a Tower system',
+    [
+        'hostname',
+        'instance_uuid',
+    ],
+)
+INSTANCE_REMAINING_CAPACITY = Gauge(
+    'awx_instance_remaining_capacity',
+    'Remaining capacity of each node in a Tower system',
+    [
+        'hostname',
+        'instance_uuid',
+    ],
+)
 
 LICENSE_INSTANCE_TOTAL = Gauge('awx_license_instance_total', 'Total number of managed hosts provided by your license')
 LICENSE_INSTANCE_FREE = Gauge('awx_license_instance_free', 'Number of remaining managed hosts provided by your license')
@@ -55,18 +121,20 @@ LICENSE_INSTANCE_FREE = Gauge('awx_license_instance_free', 'Number of remaining
 
 def metrics():
     license_info = get_license()
-    SYSTEM_INFO.info({
-        'install_uuid': settings.INSTALL_UUID,
-        'insights_analytics': str(settings.INSIGHTS_TRACKING_STATE),
-        'tower_url_base': settings.TOWER_URL_BASE,
-        'tower_version': get_awx_version(),
-        'ansible_version': get_ansible_version(),
-        'license_type': license_info.get('license_type', 'UNLICENSED'),
-        'license_expiry': str(license_info.get('time_remaining', 0)),
-        'pendo_tracking': settings.PENDO_TRACKING_STATE,
-        'external_logger_enabled': str(settings.LOG_AGGREGATOR_ENABLED),
-        'external_logger_type': getattr(settings, 'LOG_AGGREGATOR_TYPE', 'None')
-    })
+    SYSTEM_INFO.info(
+        {
+            'install_uuid': settings.INSTALL_UUID,
+            'insights_analytics': str(settings.INSIGHTS_TRACKING_STATE),
+            'tower_url_base': settings.TOWER_URL_BASE,
+            'tower_version': get_awx_version(),
+            'ansible_version': get_ansible_version(),
+            'license_type': license_info.get('license_type', 'UNLICENSED'),
+            'license_expiry': str(license_info.get('time_remaining', 0)),
+            'pendo_tracking': settings.PENDO_TRACKING_STATE,
+            'external_logger_enabled': str(settings.LOG_AGGREGATOR_ENABLED),
+            'external_logger_type': getattr(settings, 'LOG_AGGREGATOR_TYPE', 'None'),
+        }
+    )
 
     LICENSE_INSTANCE_TOTAL.set(str(license_info.get('instance_count', 0)))
     LICENSE_INSTANCE_FREE.set(str(license_info.get('free_instances', 0)))
@@ -108,16 +176,18 @@ def metrics():
         INSTANCE_MEMORY.labels(hostname=hostname, instance_uuid=uuid).set(instance_data[uuid]['memory'])
         INSTANCE_CONSUMED_CAPACITY.labels(hostname=hostname, instance_uuid=uuid).set(instance_data[uuid]['consumed_capacity'])
         INSTANCE_REMAINING_CAPACITY.labels(hostname=hostname, instance_uuid=uuid).set(instance_data[uuid]['remaining_capacity'])
-        INSTANCE_INFO.labels(hostname=hostname, instance_uuid=uuid).info({
-            'enabled': str(instance_data[uuid]['enabled']),
-            'last_isolated_check': getattr(instance_data[uuid], 'last_isolated_check', 'None'),
-            'managed_by_policy': str(instance_data[uuid]['managed_by_policy']),
-            'version': instance_data[uuid]['version']
-        })
+        INSTANCE_INFO.labels(hostname=hostname, instance_uuid=uuid).info(
+            {
+                'enabled': str(instance_data[uuid]['enabled']),
+                'last_isolated_check': getattr(instance_data[uuid], 'last_isolated_check', 'None'),
+                'managed_by_policy': str(instance_data[uuid]['managed_by_policy']),
+                'version': instance_data[uuid]['version'],
+            }
+        )
 
     instance_data = job_instance_counts(None)
     for node in instance_data:
-        # skipping internal execution node (for system jobs) 
+        # skipping internal execution node (for system jobs)
         if node == '':
             continue
         types = instance_data[node].get('launch_type', {})
@@ -127,7 +197,6 @@ def metrics():
         for status, value in statuses.items():
             INSTANCE_STATUS.labels(node=node, status=status).set(value)
 
-
     return generate_latest()