lighthouse_garden.lighthouse.process

Complexity

Total Complexity

15

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Importance

Changes

0

6 Functions

Rating	Name	Duplication	Size	Complexity
A	lighthouse()	0	18	2
A	generate_output_name()	0	6	1
A	build_options()	0	12	1
A	fetch_data()	0	20	3
B	generate_badges()	0	36	7
A	generate_badge()	0	14	1

#!/usr/bin/env python3

Missing module docstring

# -*- coding: future_fstrings -*-

import datetime
import anybadge
from lighthouse_garden.utility import info, output, system
from lighthouse_garden.lighthouse import database, utility, interpreter


def fetch_data():
    """
    Fetch the lighthouse data of all given targets
    :return:
    """
    output.println(f'{output.Subject.INFO} Checking export path', verbose_only=True)
    system.check_path(f'{system.config["export_path"]}/{system.config["data_dir"]}')

    output.println(f'{output.Subject.INFO} Starting to process targets')
    for target in system.config['targets']:
        _output_name = lighthouse(target)
        _result = interpreter.get_result_by_report_file(target, _output_name)
        if _result:
            database.set_data(target, _result)
            output.println(f'{output.Subject.OK} > {info.get_target_name(target)} ... {_result["performance"]}')

This line is too long as per the coding-style (112/100).

            utility.extend_html_report_with_info(_result, f'{utility.get_data_dir()}{_output_name}.report.html')

This line is too long as per the coding-style (112/100).

            generate_badges(target)
        else:
            utility.remove_file(f'{utility.get_data_dir()}{_output_name}.report.html')
        utility.remove_file(f'{utility.get_data_dir()}{_output_name}.report.json')


def lighthouse(target):
    """
    Fetch the lighthouse data of a specific target
    :param target: Dict
    :return:
    """
    output.println(f'{output.Subject.INFO} Fetching performance data for {info.get_target_name(target)}', verbose_only=True)

This line is too long as per the coding-style (124/100).

    _output_name = generate_output_name(target)
    _result = system.run_command(
        f'lighthouse {target["url"]} {build_options(_output_name)}', allow_fail=True
    )

    if not _result:
        output.println(f'{output.Subject.ERROR} > {info.get_target_name(target)} ...')
        system.config['errors'] = True

    return _output_name


def build_options(output_name):
    """
    Build the lighthouse options
    @ToDo: Use a separate config file?
    :param output_name: String
    :return:
    """
    _options = system.config['lighthouse']['options']
    _options += f' --chrome-flags="{system.config["lighthouse"]["chrome_flags"]}"'
    _options += f' --output json --output html --output-path {system.config["export_path"]}/{system.config["data_dir"]}' \

This line is too long as per the coding-style (122/100).

                f'{output_name}'
    return _options


def generate_output_name(target):
    """
    Generate a temporary output name, e.g. _google_28-12-2020_15-59
    :return:
    """
    return f'_{target["identifier"]}_{datetime.datetime.now().strftime("%d-%m-%Y_%H-%M")}'


def generate_badges(target):
    """
    Generate the badges for the various metrics of a specific target
    :param target: Dict
    :return:
    """
    output.println(f'{output.Subject.INFO} Generating badges', verbose_only=True)
    data = database.get_data(target)
    badges = {
        'performance': {
            'label': 'performance',
            'value': data['performance'] if 'performance' in data else '',
         },

Wrong hanging indentation.

        'accessibility': {
            'label': 'accessibility',
            'value': data['accessibility'] if 'accessibility' in data else '',
        },
        'best-practices': {
            'label': 'best-practices',
            'value': data['best-practices'] if 'best-practices' in data else '',
        },
        'seo': {
            'label': 'seo',
            'value': data['seo'] if 'seo' in data else '',
        },
        'average': {
            'label': 'performance',
            'value': data['average']['value'] if 'average' in data else '',
        }
    }

    for key, value in badges.items():
        generate_badge(
            target=target,
            layout=value,
            attribute=key
        )


def generate_badge(target, layout, attribute):
    """
    Generate a badge
    :param target: Dict
    :param layout: Dict
    :param attribute: String
    :return:
    """
    thresholds = {50: 'red',
                  90: 'yellow',
                  100: 'green'}
    badge = anybadge.Badge(layout['label'], round(layout['value']), thresholds=thresholds)

    badge.write_badge(f'{utility.get_data_dir()}_{target["identifier"]}.{attribute}.svg', overwrite=True)

This line is too long as per the coding-style (105/100).