From 142ec2f33945b549fbc9c2decd179cc0581cb55c Mon Sep 17 00:00:00 2001 From: Scott Date: Mon, 17 Jan 2022 20:30:08 -0800 Subject: [PATCH] Creates a function_utils and pull a function_identifer method into it. --- function_utils.py | 26 ++++++++++++++++++++++++++ logging_utils.py | 29 ++++------------------------- unittest_utils.py | 39 +++++++++------------------------------ 3 files changed, 39 insertions(+), 55 deletions(-) create mode 100644 function_utils.py diff --git a/function_utils.py b/function_utils.py new file mode 100644 index 0000000..5b70981 --- /dev/null +++ b/function_utils.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 + +from typing import Callable + + +def function_identifier(f: Callable) -> str: + """ + Given a callable function, return a string that identifies it. + Usually that string is just __module__:__name__ but there's a + corner case: when __module__ is __main__ (i.e. the callable is + defined in the same module as __main__). In this case, + f.__module__ returns "__main__" instead of the file that it is + defined in. Work around this using pathlib.Path (see below). + + >>> function_identifier(function_identifier) + 'function_utils:function_identifier' + + """ + if f.__module__ == '__main__': + from pathlib import Path + import __main__ + module = __main__.__file__ + module = Path(module).stem + return f'{module}:{f.__name__}' + else: + return f'{f.__module__}:{f.__name__}' diff --git a/logging_utils.py b/logging_utils.py index ddea102..c04d76d 100644 --- a/logging_utils.py +++ b/logging_utils.py @@ -159,29 +159,6 @@ built_in_print = print logging_initialized = False -def function_identifier(f: Callable) -> str: - """ - Given a callable function, return a string that identifies it. - Usually that string is just __module__:__name__ but there's a - corner case: when __module__ is __main__ (i.e. the callable is - defined in the same module as __main__). In this case, - f.__module__ returns "__main__" instead of the file that it is - defined in. Work around this using pathlib.Path (see below). - - >>> function_identifier(function_identifier) - 'logging_utils:function_identifier' - - """ - if f.__module__ == '__main__': - from pathlib import Path - import __main__ - module = __main__.__file__ - module = Path(module).stem - return f'{module}:{f.__name__}' - else: - return f'{f.__module__}:{f.__name__}' - - # A map from logging_callsite_id -> count of logged messages. squelched_logging_counts: Mapping[str, int] = {} @@ -200,7 +177,8 @@ def squelch_repeated_log_messages(squelch_after_n_repeats: int) -> Callable: """ def squelch_logging_wrapper(f: Callable): - identifier = function_identifier(f) + import function_utils + identifier = function_utils.function_identifier(f) squelched_logging_counts[identifier] = squelch_after_n_repeats return f return squelch_logging_wrapper @@ -334,7 +312,8 @@ def logging_is_probabilistic(probability_of_logging: float) -> Callable: """ def probabilistic_logging_wrapper(f: Callable): - identifier = function_identifier(f) + import function_utils + identifier = function_utils.function_identifier(f) probabilistic_logging_levels[identifier] = probability_of_logging return f return probabilistic_logging_wrapper diff --git a/unittest_utils.py b/unittest_utils.py index 584eb3c..5f45283 100644 --- a/unittest_utils.py +++ b/unittest_utils.py @@ -24,6 +24,7 @@ import warnings import bootstrap import config +import function_utils import scott_secrets import sqlalchemy as sa @@ -145,29 +146,6 @@ class DatabasePerfRegressionDataPersister(PerfRegressionDataPersister): self.conn.execute(sql) -def function_identifier(f: Callable) -> str: - """ - Given a callable function, return a string that identifies it. - Usually that string is just __module__:__name__ but there's a - corner case: when __module__ is __main__ (i.e. the callable is - defined in the same module as __main__). In this case, - f.__module__ returns "__main__" instead of the file that it is - defined in. Work around this using pathlib.Path (see below). - - >>> function_identifier(function_identifier) - 'unittest_utils:function_identifier' - - """ - if f.__module__ == '__main__': - from pathlib import Path - import __main__ - module = __main__.__file__ - module = Path(module).stem - return f'{module}:{f.__name__}' - else: - return f'{f.__module__}:{f.__name__}' - - def check_method_for_perf_regressions(func: Callable) -> Callable: """ This is meant to be used on a method in a class that subclasses @@ -191,8 +169,9 @@ def check_method_for_perf_regressions(func: Callable) -> Callable: 'Unknown/unexpected --unittests_persistance_strategy value' ) - logger.debug(f'Watching {func.__name__}\'s performance...') - func_id = function_identifier(func) + func_id = function_utils.function_identifier(func) + func_name = func.__name__ + logger.debug(f'Watching {func_name}\'s performance...') logger.debug(f'Canonical function identifier = {func_id}') try: @@ -220,19 +199,19 @@ def check_method_for_perf_regressions(func: Callable) -> Callable: if len(hist) < config.config['unittests_num_perf_samples']: hist.append(run_time) logger.debug( - f'Still establishing a perf baseline for {func.__name__}' + f'Still establishing a perf baseline for {func_name}' ) else: stdev = statistics.stdev(hist) - logger.debug(f'For {func.__name__}, performance stdev={stdev}') + logger.debug(f'For {func_name}, performance stdev={stdev}') slowest = hist[-1] - logger.debug(f'For {func.__name__}, slowest perf on record is {slowest:f}s') + logger.debug(f'For {func_name}, slowest perf on record is {slowest:f}s') limit = slowest + stdev * 4 logger.debug( - f'For {func.__name__}, max acceptable runtime is {limit:f}s' + f'For {func_name}, max acceptable runtime is {limit:f}s' ) logger.debug( - f'For {func.__name__}, actual observed runtime was {run_time:f}s' + f'For {func_name}, actual observed runtime was {run_time:f}s' ) if ( run_time > limit and -- 2.45.2