lighthouse_garden.lighthouse.database.get_result_by_report_file() - Code Metrics - Inspection of "[Doc] Further code documentation" - jackd248/lighthouse-garden - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 5f3343...033868 )

by Konrad

created 2021-01-10 18:42 UTC

get_result_by_report_file() F

↳ Parent: lighthouse_garden.lighthouse.database

Complexity

Conditions

Size

Total Lines	73
Code Lines	44

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	44
dl	0
loc	73
rs	1.8
c	0
b	0
f	0
cc	17
nop	2

How to fix Long Method Complexity

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

If many parameters/temporary variables are present:
- Replace temporary variables with Query
- Introduce parameter object; often combined with preserve whole object
- If the above two are insufficient: Replace method with method object
If you have long conditionals: Decompose Conditional
Otherwise: Extract method

Complexity

Complex classes like lighthouse_garden.lighthouse.database.get_result_by_report_file() often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

#!/usr/bin/env python3

# -*- coding: future_fstrings -*-

import json
import os

from lighthouse_garden.utility import output, system
from lighthouse_garden.lighthouse import utility


def get_data(target, file_suffix=''):
    """
    Get json data file by target
    :param target: Dict
    :param file_suffix: String Additional suffix
    :return: Dict
    """
    data_file = f'{utility.get_data_dir()}_{target["identifier"]}{file_suffix}.json'
    if os.path.isfile(data_file):
        with open(data_file, 'r') as read_file:
            return json.load(read_file)
    else:
        return []


def set_data(target, data, file_suffix=''):
    """
    Write json data by target
    :param target: Dict
    :param data: Dict
    :param file_suffix: String Additional suffix
    :return:
    """
    data_file = f'{utility.get_data_dir()}_{target["identifier"]}{file_suffix}.json'
    with open(data_file, 'w') as write_file:
        json.dump(data, write_file)


def add_value_to_history(target, result):
    """
    Adding a new result value to the history data of a specific target
    :param target: Dict
    :param result: Dict
    :return:
    """
    _data = get_data(target, '.history')
    while len(_data) > system.config['keep_history']:
        output.println(f'{output.Subject.INFO} Cleaning history value', verbose_only=True)
        utility.remove_file(f'{utility.get_export_dir()}{_data[0]["report"]}')
        del _data[0]
    _data.append(result)
    set_data(target, _data, '.history')


def get_average_by_attribute(target, attribute):
    """
    Calculates the average value from a specific attribute by all available history values
    :param target: Dict
    :param attribute: String
    :return: Float
    """
    history_data = get_history_by_attribute(target, attribute)
    return sum(history_data) / float(len(history_data))


def get_average_peak(target, attribute, min_max=True):
    """
    Get the min or max value of a specific attribute by all available history values
    :param target:
    :param attribute:
    :param min_max:
    :return:
    """
    history_data = get_history_by_attribute(target, attribute)

    if min_max:

        return min(history_data)
    else:
        return max(history_data)


def get_history_by_attribute(target, attribute):
    """
    Fetch all history values of a specific attribute
    :param target: Dict
    :param attribute: String
    :return:
    """
    history_data = []
    for history in get_data(target, '.history'):
        history_data.append(history[attribute])
    return history_data


def get_target_by_attribute(value, attribute):
    """
    Return a target by a specific attribute
    :param value: String
    :param attribute: String
    :return:
    """
    for target in system.config['targets']:
        if target[attribute] == value:
            return target
    return None


def get_last_results():
    """
    Get last results of all targets
    :return: Dict
    """
    results = []
    for target in system.config['targets']:
        _result = get_data(target)
        if _result:
            results.append(_result)

    # sort by performance
    results.sort(key=lambda x: x['performance'], reverse=True)

    return results


def get_last_value(target, attribute):
    """
    Get the last value of a specific attribute
    :param target: Dict
    :param attribute: String
    :return:
    """
    _result = get_data(target, '.history')
    return _result[-1][attribute]


def sort_by_average(results):
    """
    Sort the dict by the average value
    :param results: Dict
    :return: Dict
    """
    # sort by average
    results.sort(key=lambda x: x['average']['value'], reverse=True)
    return results


1			#!/usr/bin/env python3
			0 ignored issues – show introduced 2021-01-03 18:32 UTC by Report Bug Copy Issue Report Missing module docstring Loading history...
2			# -- coding: future_fstrings --
3
4			import json
5			import os
6
7			from lighthouse_garden.utility import output, system
8			from lighthouse_garden.lighthouse import utility
9
10
11			def get_data(target, file_suffix=''):
12			"""
13			Get json data file by target
14			:param target: Dict
15			:param file_suffix: String Additional suffix
16			:return: Dict
17			"""
18			data_file = f'{utility.get_data_dir()}_{target["identifier"]}{file_suffix}.json'
19			if os.path.isfile(data_file):
20			with open(data_file, 'r') as read_file:
21			return json.load(read_file)
22			else:
23			return []
24
25
26			def set_data(target, data, file_suffix=''):
27			"""
28			Write json data by target
29			:param target: Dict
30			:param data: Dict
31			:param file_suffix: String Additional suffix
32			:return:
33			"""
34			data_file = f'{utility.get_data_dir()}_{target["identifier"]}{file_suffix}.json'
35			with open(data_file, 'w') as write_file:
36			json.dump(data, write_file)
37
38
39			def add_value_to_history(target, result):
40			"""
41			Adding a new result value to the history data of a specific target
42			:param target: Dict
43			:param result: Dict
44			:return:
45			"""
46			_data = get_data(target, '.history')
47			while len(_data) > system.config['keep_history']:
48			output.println(f'{output.Subject.INFO} Cleaning history value', verbose_only=True)
49			utility.remove_file(f'{utility.get_export_dir()}{_data[0]["report"]}')
50			del _data[0]
51			_data.append(result)
52			set_data(target, _data, '.history')
53
54
55			def get_average_by_attribute(target, attribute):
56			"""
57			Calculates the average value from a specific attribute by all available history values
58			:param target: Dict
59			:param attribute: String
60			:return: Float
61			"""
62			history_data = get_history_by_attribute(target, attribute)
63			return sum(history_data) / float(len(history_data))
64
65
66			def get_average_peak(target, attribute, min_max=True):
67			"""
68			Get the min or max value of a specific attribute by all available history values
69			:param target:
70			:param attribute:
71			:param min_max:
72			:return:
73			"""
74			history_data = get_history_by_attribute(target, attribute)
75
76			if min_max:
			0 ignored issues – show unused-code introduced 2021-01-10 17:35 UTC by Report Bug Copy Issue Report Unnecessary "else" after "return" Loading history...
77			return min(history_data)
78			else:
79			return max(history_data)
80
81
82			def get_history_by_attribute(target, attribute):
83			"""
84			Fetch all history values of a specific attribute
85			:param target: Dict
86			:param attribute: String
87			:return:
88			"""
89			history_data = []
90			for history in get_data(target, '.history'):
91			history_data.append(history[attribute])
92			return history_data
93
94
95			def get_target_by_attribute(value, attribute):
96			"""
97			Return a target by a specific attribute
98			:param value: String
99			:param attribute: String
100			:return:
101			"""
102			for target in system.config['targets']:
103			if target[attribute] == value:
104			return target
105			return None
106
107
108			def get_last_results():
109			"""
110			Get last results of all targets
111			:return: Dict
112			"""
113			results = []
114			for target in system.config['targets']:
115			_result = get_data(target)
116			if _result:
117			results.append(_result)
118
119			# sort by performance
120			results.sort(key=lambda x: x['performance'], reverse=True)
121
122			return results
123
124
125			def get_last_value(target, attribute):
126			"""
127			Get the last value of a specific attribute
128			:param target: Dict
129			:param attribute: String
130			:return:
131			"""
132			_result = get_data(target, '.history')
133			return _result[-1][attribute]
134
135
136			def sort_by_average(results):
137			"""
138			Sort the dict by the average value
139			:param results: Dict
140			:return: Dict
141			"""
142			# sort by average
143			results.sort(key=lambda x: x['average']['value'], reverse=True)
144			return results
145

jackd248 / lighthouse-garden

Push — master ( 5f3343...033868 )

get_result_by_report_file() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like