10858737368

Committed 14 Sep 2024 02:22AM UTC coverage: 67.194% (-0.04%) from 67.23%

Build # 10858737368

Build Type

Pull #1177

github

Committed by

BelhsanHmida

Commit Message

Correctly refactor flatten as classmethode and calling it

Signed-off-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>

Pull Request Pull Request #1177: Improve 'Add titles to asset page graphs' implementation

Run Details

6238 of 10120 branches covered (61.64%)

Branch coverage included in aggregate %.

15 of 22 new or added lines in 2 files covered. (68.18%)

5 existing lines in 2 files now uncovered.

7874 of 10882 relevant lines covered (72.36%)

5.73 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

55.56

/flexmeasures/utils/coding_utils.py

""" Various coding utils (e.g. around function decoration) """
from __future__ import annotations

import functools
import time
import inspect
import importlib
import pkgutil
from flask import current_app


def delete_key_recursive(value, key):
    """Delete key in a multilevel dictionary"""
    if isinstance(value, dict):

        if key in value:
            del value[key]

        for k, v in value.items():
            value[k] = delete_key_recursive(v, key)

        # value.pop(key, None)
    elif isinstance(value, list):
        for i, v in enumerate(value):
            value[i] = delete_key_recursive(v, key)

    return value


def optional_arg_decorator(fn):
    """
    A decorator which _optionally_ accepts arguments.

    So a decorator like this:

    @optional_arg_decorator
    def register_something(fn, optional_arg = 'Default Value'):
        ...
        return fn

    will work in both of these usage scenarios:

    @register_something('Custom Name')
    def custom_name():
        pass

    @register_something
    def default_name():
        pass

    Thanks to https://stackoverflow.com/questions/3888158/making-decorators-with-optional-arguments#comment65959042_24617244
    """

    def wrapped_decorator(*args):
        if len(args) == 1 and callable(args[0]):
            return fn(args[0])
        else:

            def real_decorator(decoratee):
                return fn(decoratee, *args)

            return real_decorator

    return wrapped_decorator


def sort_dict(unsorted_dict: dict) -> dict:
    sorted_dict = dict(sorted(unsorted_dict.items(), key=lambda item: item[0]))
    return sorted_dict


# This function is used for sensors_to_show in follow-up PR it will be moved and renamed to flatten_sensors_to_show
def flatten_unique(nested_list_of_objects: list) -> list:
    """
    Get unique sensor IDs from a list of `sensors_to_show`.

    Handles:
    - Lists of sensor IDs
    - Dictionaries with a `sensors` key
    - Nested lists (one level)

    Example:
        Input:
        [1, [2, 20, 6], 10, [6, 2], {"title":None,"sensors": [10, 15]}, 15]

        Output:
        [1, 2, 20, 6, 10, 15]
    """
    all_objects = []
    for s in nested_list_of_objects:
        if isinstance(s, list):
            all_objects.extend(s)
        elif isinstance(s, dict):
            all_objects.extend(s["sensors"])
        else:
            all_objects.append(s)
    return list(dict.fromkeys(all_objects).keys())


def timeit(func):
    """Decorator for printing the time it took to execute the decorated function."""

    @functools.wraps(func)
    def new_func(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        elapsed_time = time.time() - start_time
        print(f"{func.__name__} finished in {int(elapsed_time * 1_000)} ms")
        return result

    return new_func


def deprecated(alternative, version: str | None = None):
    """Decorator for printing a warning error.
    alternative: importable object to use as an alternative to the function/method decorated
    version: version in which the function will be sunset
    """

    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            current_app.logger.warning(
                f"The method or function {func.__name__} is deprecated and it is expected to be sunset in version {version}. Please, switch to using {inspect.getmodule(alternative).__name__}:{alternative.__name__} to suppress this warning."
            )

            return func(*args, **kwargs)

        return wrapper

    return decorator


def find_classes_module(module, superclass):
    classes = []

    module_object = importlib.import_module(f"{module}")
    module_classes = inspect.getmembers(module_object, inspect.isclass)

    classes.extend(
        [
            (class_name, klass)
            for class_name, klass in module_classes
            if issubclass(klass, superclass) and klass != superclass
        ]
    )

    return classes


def find_classes_modules(module, superclass, skiptest=True):
    classes = []

    base_module = importlib.import_module(module)

    # root (__init__.py) of the base module
    classes += find_classes_module(module, superclass)

    for submodule in pkgutil.iter_modules(base_module.__path__):

        if skiptest and ("test" in f"{module}.{submodule.name}"):
            continue

        if submodule.ispkg:
            classes.extend(
                find_classes_modules(
                    f"{module}.{submodule.name}", superclass, skiptest=skiptest
                )
            )
        else:
            classes += find_classes_module(f"{module}.{submodule.name}", superclass)

    return classes


def get_classes_module(module, superclass, skiptest=True) -> dict:
    return dict(find_classes_modules(module, superclass, skiptest=skiptest))

1	""" Various coding utils (e.g. around function decoration) """	4✔
2	from __future__ import annotations	8✔
3
4	import functools	8✔
5	import time	8✔
6	import inspect	8✔
7	import importlib	8✔
8	import pkgutil	8✔
9	from flask import current_app	8✔
10
11
12	def delete_key_recursive(value, key):	8✔
13	"""Delete key in a multilevel dictionary"""
14	if isinstance(value, dict):	×
15
16	if key in value:	×
17	del value[key]	×
18
19	for k, v in value.items():	×
20	value[k] = delete_key_recursive(v, key)	×
21
22	# value.pop(key, None)
23	elif isinstance(value, list):	×
24	for i, v in enumerate(value):	×
25	value[i] = delete_key_recursive(v, key)	×
26
27	return value	×
28
29
30	def optional_arg_decorator(fn):	8✔
31	"""
32	A decorator which _optionally_ accepts arguments.
33
34	So a decorator like this:
35
36	@optional_arg_decorator
37	def register_something(fn, optional_arg = 'Default Value'):
38	...
39	return fn
40
41	will work in both of these usage scenarios:
42
43	@register_something('Custom Name')
44	def custom_name():
45	pass
46
47	@register_something
48	def default_name():
49	pass
50
51	Thanks to https://stackoverflow.com/questions/3888158/making-decorators-with-optional-arguments#comment65959042_24617244
52	"""
53
54	def wrapped_decorator(*args):	8✔
55	if len(args) == 1 and callable(args[0]):	×
56	return fn(args[0])	×
57	else:
58
59	def real_decorator(decoratee):	×
60	return fn(decoratee, *args)	×
61
62	return real_decorator	×
63
64	return wrapped_decorator	8✔
65
66
67	def sort_dict(unsorted_dict: dict) -> dict:	8✔
68	sorted_dict = dict(sorted(unsorted_dict.items(), key=lambda item: item[0]))	×
69	return sorted_dict	×
70
71
72	# This function is used for sensors_to_show in follow-up PR it will be moved and renamed to flatten_sensors_to_show
73	def flatten_unique(nested_list_of_objects: list) -> list:	8✔
74	"""
75	Get unique sensor IDs from a list of `sensors_to_show`.
76
77	Handles:
78	- Lists of sensor IDs
79	- Dictionaries with a `sensors` key
80	- Nested lists (one level)
81
82	Example:
83	Input:
84	[1, [2, 20, 6], 10, [6, 2], {"title":None,"sensors": [10, 15]}, 15]
85
86	Output:
87	[1, 2, 20, 6, 10, 15]
88	"""
89	all_objects = []	8✔
90	for s in nested_list_of_objects:	8✔
UNCOV 91	if isinstance(s, list):	×
92	all_objects.extend(s)	×
UNCOV 93	elif isinstance(s, dict):	×
UNCOV 94	all_objects.extend(s["sensors"])	×
95	else:
UNCOV 96	all_objects.append(s)	×
97	return list(dict.fromkeys(all_objects).keys())	8✔
98
99
100	def timeit(func):	8✔
101	"""Decorator for printing the time it took to execute the decorated function."""
102
103	@functools.wraps(func)	×
104	def new_func(args, *kwargs):	×
105	start_time = time.time()	×
106	result = func(args, *kwargs)	×
107	elapsed_time = time.time() - start_time	×
108	print(f"{func.__name__} finished in {int(elapsed_time * 1_000)} ms")	×
109	return result	×
110
111	return new_func	×
112
113
114	def deprecated(alternative, version: str \| None = None):	8✔
115	"""Decorator for printing a warning error.
116	alternative: importable object to use as an alternative to the function/method decorated
117	version: version in which the function will be sunset
118	"""
119
120	def decorator(func):	8✔
121	@functools.wraps(func)	8✔
122	def wrapper(args, *kwargs):	8✔
123	current_app.logger.warning(	8✔
124	f"The method or function {func.__name__} is deprecated and it is expected to be sunset in version {version}. Please, switch to using {inspect.getmodule(alternative).__name__}:{alternative.__name__} to suppress this warning."
125	)
126
127	return func(args, *kwargs)	8✔
128
129	return wrapper	8✔
130
131	return decorator	8✔
132
133
134	def find_classes_module(module, superclass):	8✔
135	classes = []	8✔
136
137	module_object = importlib.import_module(f"{module}")	8✔
138	module_classes = inspect.getmembers(module_object, inspect.isclass)	8✔
139
140	classes.extend(	8✔
141	[
142	(class_name, klass)
143	for class_name, klass in module_classes
144	if issubclass(klass, superclass) and klass != superclass
145	]
146	)
147
148	return classes	8✔
149
150
151	def find_classes_modules(module, superclass, skiptest=True):	8✔
152	classes = []	8✔
153
154	base_module = importlib.import_module(module)	8✔
155
156	# root (__init__.py) of the base module
157	classes += find_classes_module(module, superclass)	8✔
158
159	for submodule in pkgutil.iter_modules(base_module.__path__):	8✔
160
161	if skiptest and ("test" in f"{module}.{submodule.name}"):	8✔
162	continue	8✔
163
164	if submodule.ispkg:	8✔
165	classes.extend(	8✔
166	find_classes_modules(
167	f"{module}.{submodule.name}", superclass, skiptest=skiptest
168	)
169	)
170	else:
171	classes += find_classes_module(f"{module}.{submodule.name}", superclass)	8✔
172
173	return classes	8✔
174
175
176	def get_classes_module(module, superclass, skiptest=True) -> dict:	8✔
177	return dict(find_classes_modules(module, superclass, skiptest=skiptest))	8✔

FlexMeasures / flexmeasures / 10858737368

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous