atomicshop 2.16.30__py3-none-any.whl → 2.16.32__py3-none-any.whl

atomicshop/__init__.py

@@ -1,4 +1,4 @@
 """Atomic Basic functions and classes to make developer life easier"""
 
 __author__ = "Den Kras"
-__version__ = '2.16.30'
+__version__ = '2.16.32'

atomicshop/basics/booleans.py

@@ -1,47 +1,35 @@
-def check_3_booleans_when_only_1_can_be_true(
-        boolean1: tuple,
-        boolean2: tuple,
-        boolean3: tuple
+def is_only_1_true_in_list(
+        booleans_list_of_tuples: list[tuple],
+        raise_if_all_false: bool = True
 ) -> None:
     """
-    Check if only one boolean can be 'True' from 3 booleans
-
-    :param boolean1: tuple, (value, string name of the setting you want to print to the user to be aware of).
-    :param boolean2: tuple, (value, string name of the setting you want to print to the user to be aware of).
-    :param boolean3: tuple, (value, string name of the setting you want to print to the user to be aware of).
-    :return:
-
-    ------------------------------------------------
-
-    Example:
-        check_3_booleans_when_only_1_can_be_true(
-            (self.config['section']['default_usage'], 'default_usage'),
-            (self.config['section']['create_usage'], 'create_usage'),
-            (self.config['section']['custom_usage'], 'custom_usage'))
+    Check if only one boolean can be 'True' from a list of booleans
+    :param booleans_list_of_tuples: list of tuples, Structure:
+        [(value, string name of the setting you want to print to the user to be aware of), ...]
+    :param raise_if_all_false: bool, If True, exception will be raised if all booleans are False.
+    :return: None
     """
 
-    check_if_3_booleans_are_false(boolean1, boolean2, boolean3)
-    check_if_2_booleans_are_true(boolean1, boolean2)
-    check_if_2_booleans_are_true(boolean1, boolean3)
-    check_if_2_booleans_are_true(boolean2, boolean3)
-
-
-def check_if_3_booleans_are_false(boolean1: tuple, boolean2: tuple, boolean3: tuple):
-    if not boolean1[0] and not boolean2[0] and not boolean3[0]:
-        message = f"All the boolean settings in config ini file were set to 'False',\n" \
-                  f"You need at least one 'True':\n" \
-                  f"{boolean1[1]}={boolean1[0]}\n" \
-                  f"{boolean2[1]}={boolean2[0]}\n" \
-                  f"{boolean3[1]}={boolean3[0]}"
-        raise ValueError(message)
-
-
-def check_if_2_booleans_are_true(boolean1: tuple, boolean2: tuple) -> None:
-    if boolean1[0] and boolean2[0]:
-        message = f"Only one configuration can be 'True':\n" \
-                  f"{boolean1[1]}={boolean1[0]}\n" \
-                  f"{boolean2[1]}={boolean2[0]}\n"
-        raise ValueError(message)
+    # Filter to get all the `True` conditions and their associated names
+    true_conditions = [name for value, name in booleans_list_of_tuples if value]
+
+    # Count the number of True values
+    true_count = len(true_conditions)
+
+    if true_count == 1:
+        # Only one value is True, which is acceptable
+        # print(f"Only one condition is True: {true_conditions[0]}.")
+        pass
+    elif true_count > 1:
+        # More than one value is True, raise an exception
+        raise ValueError(f"Multiple conditions are True: {', '.join(true_conditions)}.")
+    elif true_count == 0 and raise_if_all_false:
+        # None of the values are True, and the user does not want to ignore this case
+        raise ValueError("No conditions are True, and raise_if_all_false is set to True.")
+    else:
+        # If no True values and no_raise_if_all_false is True, just pass silently
+        # print("No conditions are True (but raise_if_all_false is set to False).")
+        pass
 
 
 def convert_string_to_bool(string: str) -> bool:

atomicshop/config_init.py

@@ -2,7 +2,7 @@ import os
 
 from .file_io import tomls
 from . import filesystem
-from .print_api import print_api
+from . import print_api
 
 CONFIG_FILE_NAME = 'config.toml'
 CONFIG: dict = dict()
@@ -45,7 +45,7 @@ def write_config(
         'CONFIG_FILE_NAME'.
     :param print_message: boolean, if True, the function will print the message about the created config file.
         Also, it will wait for the user to press Enter to exit the script.
-        If False, the function will not print anything and will not exit..
+        If False, the function will not print anything and will not exit.
     :return:
     """
 
@@ -62,7 +62,7 @@ def write_config(
         tomls.write_toml_file(config, f'{script_directory}{os.sep}{config_file_name}')
 
         if print_message:
-            print_api(f"Created config file: {config_file_path}", color="yellow")
-            print_api(f"You need to fill it with details.", color="yellow")
+            print_api.print_api(f"Created config file: {config_file_path}", color="yellow")
+            print_api.print_api(f"You need to fill it with details.", color="yellow")
             input("Press Enter to exit.")
             exit()

atomicshop/file_io/csvs.py

@@ -2,11 +2,10 @@ import csv
 import io
 from typing import Tuple, List
 
-from .file_io import read_file_decorator
 from . import file_io
 
 
-@read_file_decorator
+@file_io.read_file_decorator
 def read_csv_to_list_of_dicts_by_header(
         file_path: str,
         file_mode: str = 'r',
@@ -53,7 +52,7 @@ def read_csv_to_list_of_dicts_by_header(
     return csv_list, header
 
 
-@read_file_decorator
+@file_io.read_file_decorator
 def read_csv_to_list_of_lists(
         file_path: str,
         file_mode: str = 'r',

atomicshop/file_io/file_io.py

@@ -2,7 +2,7 @@ from typing import Union
 import functools
 
 from .. import print_api
-from ..inspect_wrapper import get_target_function_default_args_and_combine_with_current
+from .. import inspect_wrapper
 
 
 def get_write_file_mode_string_from_overwrite_bool(overwrite: bool) -> str:
@@ -17,7 +17,8 @@ def write_file_decorator(function_name):
     def wrapper_write_file_decorator(*args, **kwargs):
         # Put 'args' into 'kwargs' with appropriate key.
         # args, kwargs = put_args_to_kwargs(function_name, *args, **kwargs)
-        args, kwargs = get_target_function_default_args_and_combine_with_current(function_name, *args, **kwargs)
+        args, kwargs = inspect_wrapper.get_target_function_default_args_and_combine_with_current(
+            function_name, *args, **kwargs)
 
         print_api.print_api(message=f"Writing file: {kwargs['file_path']}", **kwargs)
 
@@ -51,7 +52,8 @@ def read_file_decorator(function_name):
     def wrapper_read_file_decorator(*args, **kwargs):
         # Put 'args' into 'kwargs' with appropriate key.
         # args, kwargs = put_args_to_kwargs(function_name, *args, **kwargs)
-        args, kwargs = get_target_function_default_args_and_combine_with_current(function_name, *args, **kwargs)
+        args, kwargs = inspect_wrapper.get_target_function_default_args_and_combine_with_current(
+            function_name, *args, **kwargs)
 
         continue_loop: bool = True
         while continue_loop:

atomicshop/mitm/engines/__parent/recorder___parent.py

@@ -2,9 +2,9 @@ import os
 from datetime import datetime
 import json
 
-from ...shared_functions import build_module_names, create_custom_logger, get_json
+from ...shared_functions import build_module_names, create_custom_logger
 from ... import message, recs_files
-from .... import filesystem, urls
+from .... import filesystem
 from ....file_io import file_io
 
 
@@ -46,21 +46,6 @@ class RecorderParent:
         # Build the record path with file name
         self.build_record_path_to_engine()
 
-        # Define empty 'http_path'.
-        http_path: str = str()
-        # If 'self.class_client_message.request_raw_decoded.path' will be undefined, exception will raise.
-        # This will happen if the message is not HTTP.
-        try:
-            # Parse the url to components.
-            http_path_parsed = urls.url_parser(self.class_client_message.request_raw_decoded.path)
-            # Get only directories.
-            http_path_directories_string = '-'.join(http_path_parsed['directories'])
-            # Add '_' character before 'http_path' to look better on the file name.
-            http_path = f'_{http_path_directories_string}'
-        # If 'self.class_client_message.request_raw_decoded.path' is not defined, we'll pass the exception.
-        except Exception:
-            pass
-
         # If HTTP Path is not defined, 'http_path' will be empty, and it will not interfere with file name.
         self.record_file_path: str = \
             self.engine_record_path + os.sep + \
@@ -88,7 +73,6 @@ class RecorderParent:
         # Convert the requests and responses to hex.
         self.convert_messages()
         # Get the message in dict / JSON format
-        # record_message = get_json(self.class_client_message)
         record_message_dict: dict = dict(self.class_client_message)
         recorded_message_json_string = json.dumps(record_message_dict)
 

atomicshop/mitm/import_config.py

@@ -93,19 +93,20 @@ def check_configurations() -> int:
             print_api(message, color='red')
             return 1
 
-    if config_static.DNSServer.set_default_dns_gateway or \
-            config_static.DNSServer.set_default_dns_gateway_to_localhost or \
-            config_static.DNSServer.set_default_dns_gateway_to_default_interface_ipv4:
-        try:
-            booleans.check_3_booleans_when_only_1_can_be_true(
+    try:
+        booleans.is_only_1_true_in_list(
+            booleans_list_of_tuples=[
                 (config_static.DNSServer.set_default_dns_gateway, '[dns][set_default_dns_gateway]'),
                 (config_static.DNSServer.set_default_dns_gateway_to_localhost,
                  '[dns][set_default_dns_gateway_to_localhost]'),
                 (config_static.DNSServer.set_default_dns_gateway_to_default_interface_ipv4,
-                 '[dns][set_default_dns_gateway_to_default_interface_ipv4]'))
-        except ValueError as e:
-            print_api(str(e), color='red')
-            return 1
+                 '[dns][set_default_dns_gateway_to_default_interface_ipv4]')
+            ],
+            raise_if_all_false=False
+        )
+    except ValueError as e:
+        print_api(str(e), color='red')
+        return 1
 
     if (config_static.DNSServer.set_default_dns_gateway or
             config_static.DNSServer.set_default_dns_gateway_to_localhost or

atomicshop/mitm/mitm_main.py

@@ -10,6 +10,7 @@ from ..permissions import permissions
 from ..python_functions import get_current_python_version_string, check_python_version_compliance
 from ..wrappers.socketw import socket_wrapper, dns_server, base
 from ..wrappers.loggingw import loggingw
+from ..wrappers.ctyping import win_console
 
 from .initialize_engines import ModuleCategory
 from .connection_thread_worker import thread_worker_main
@@ -28,6 +29,12 @@ EXCEPTIONS_CSV_LOGGER_HEADER: str = 'time,exception'
 MITM_ERROR_LOGGER: loggingw.ExceptionCsvLogger = None
 
 
+try:
+    win_console.disable_quick_edit()
+except win_console.NotWindowsConsoleError:
+    pass
+
+
 def exit_cleanup():
     if permissions.is_admin():
         is_dns_dynamic, current_dns_gateway = dns.get_default_dns_gateway()

atomicshop/mitm/recs_files.py

@@ -1,13 +1,15 @@
 import datetime
 import os
 import multiprocessing
+from pathlib import Path
 
 from ..archiver import zips
 from .. import filesystem
+from .. wrappers.loggingw import consts
 
 
-REC_FILE_DATE_TIME_FORMAT: str = "%Y_%m_%d-%H_%M_%S_%f"
-REC_FILE_DATE_FORMAT: str = REC_FILE_DATE_TIME_FORMAT.split('-')[0]
+REC_FILE_DATE_TIME_FORMAT: str = f'{consts.DEFAULT_ROTATING_SUFFIXES_FROM_WHEN["S"]}_%f'
+REC_FILE_DATE_FORMAT: str = REC_FILE_DATE_TIME_FORMAT.split('_')[0]
 
 
 def recs_archiver(recs_directory: str) -> list:

atomicshop/mitm/shared_functions.py

@@ -38,9 +38,3 @@ def create_custom_logger():
     logger_name = f'{config_static.MainConfig.LOGGER_NAME}.{engine_logger_part}'
 
     return loggingw.get_logger_with_level(logger_name)
-
-
-def get_json(obj):
-    """ Convert any nested object to json / dict and values to string as is """
-
-    return json.dumps(obj, default=dicts.convert_complex_object_to_dict)

atomicshop/mitm/statistic_analyzer.py

@@ -354,7 +354,8 @@ def deviation_calculator_by_moving_average(
         summary: bool = False,
         output_file_path: str = None,
         output_file_type: Literal['json', 'csv'] = 'json',
-        convert_sizes_lists_and_ma_data_to_string: bool = False
+        convert_sizes_lists_and_ma_data_to_string: bool = False,
+        skip_total_count_less_than: int = None
 ) -> Union[list, None]:
     """
     This function is the main function for the moving average calculator.
@@ -386,6 +387,12 @@ def deviation_calculator_by_moving_average(
     :param output_file_type: string, the type of the output file. 'json' or 'csv'.
     :param convert_sizes_lists_and_ma_data_to_string: bool, if True, the 'request_sizes', 'response_sizes' and 'ma_data'
         will be converted to string. This is useful when writing to files, so the view will be more readable.
+    :param skip_total_count_less_than: integer, if specified, the deviation calculation will be skipped
+        if the total count is less than this number.
+        This means that if we have moving average window of 7 days, on the 8th day, the deviation will be calculated
+        only if the total count of the checked type
+        (request average size, response average, request count, response count)
+        is greater or equal to this number.
     -----------------------------
     :return: the deviation list of dicts.
 
@@ -427,7 +434,8 @@ def deviation_calculator_by_moving_average(
         by_type,
         moving_average_window_days,
         top_bottom_deviation_percentage,
-        get_deviation_for_last_day_only
+        get_deviation_for_last_day_only,
+        skip_total_count_less_than
     )
 
     if deviation_list:
@@ -484,6 +492,9 @@ def deviation_calculator_by_moving_average_main():
         parser.add_argument(
             '-p', '--percentage', type=float, required=True,
             help='Percentage of deviation from moving average. Example: 0.1 for 10%%.')
+        parser.add_argument(
+            '-slt', '--skip_total_count_less_than', type=int, required=False,
+            help='An integer to skip the deviation calculation if the total count is less than this number.')
 
         return parser.parse_args()
 
@@ -517,7 +528,8 @@ def deviation_calculator_by_moving_average_main():
         summary=summary,
         output_file_path=args.output_file,
         output_file_type=args.output_type,
-        convert_sizes_lists_and_ma_data_to_string=convert_sizes_lists_and_ma_data_to_string
+        convert_sizes_lists_and_ma_data_to_string=convert_sizes_lists_and_ma_data_to_string,
+        skip_total_count_less_than=args.skip_total_count_less_than
     )
 
     return 0

atomicshop/mitm/statistic_analyzer_helper/moving_average_helper.py

@@ -14,6 +14,7 @@ def calculate_moving_average(
         moving_average_window_days,
         top_bottom_deviation_percentage: float,
         get_deviation_for_last_day_only: bool = False,
+        skip_total_count_less_than: int = None,
         print_kwargs: dict = None
 ) -> list:
     """
@@ -37,6 +38,7 @@ def calculate_moving_average(
         Files 01 to 05 will be used for moving average and the file 06 for deviation.
         Meaning the average calculated for 2021-01-06 will be compared to the values moving average of 2021-01-01
         to 2021-01-05.
+    :param skip_total_count_less_than: integer, if the total count is less than this number, skip the deviation.
     :param print_kwargs: dict, the print_api arguments.
     """
 
@@ -55,7 +57,7 @@ def calculate_moving_average(
     statistics_content: dict = {}
     # Read each file to its day.
     for log_atomic_path in logs_paths:
-        date_string = log_atomic_path.datetime_string
+        date_string: str = log_atomic_path.datetime_string
         statistics_content[date_string] = {}
 
         statistics_content[date_string]['file'] = log_atomic_path
@@ -65,11 +67,11 @@ def calculate_moving_average(
         statistics_content[date_string]['content'] = log_file_content
         statistics_content[date_string]['header'] = log_file_header
 
-        statistics_content[date_string]['content_no_errors'] = get_content_without_errors(log_file_content)
+        statistics_content[date_string]['content_no_useless'] = get_content_without_useless(log_file_content)
 
         # Get the data dictionary from the statistics content.
         statistics_content[date_string]['statistics_daily'] = compute_statistics_from_content(
-            statistics_content[date_string]['content_no_errors'], by_type)
+            statistics_content[date_string]['content_no_useless'], by_type)
 
     moving_average_dict: dict = compute_moving_averages_from_average_statistics(
         statistics_content,
@@ -85,12 +87,12 @@ def calculate_moving_average(
 
     # Find deviation from the moving average to the bottom or top by specified percentage.
     deviation_list: list = find_deviation_from_moving_average(
-        statistics_content, top_bottom_deviation_percentage)
+        statistics_content, top_bottom_deviation_percentage, skip_total_count_less_than)
 
     return deviation_list
 
 
-def get_content_without_errors(content: list) -> list:
+def get_content_without_useless(content: list) -> list:
     """
     This function gets the 'statistics.csv' file content without errors from the 'content' list.
 
@@ -101,7 +103,7 @@ def get_content_without_errors(content: list) -> list:
     traffic_statistics_without_errors: list = []
     for line in content:
         # Skip empty lines, headers and errors.
-        if line['host'] == 'host' or line['command'] == '':
+        if line['host'] == 'host' or (line['request_size_bytes'] == '' and line['response_size_bytes'] == ''):
             continue
 
         traffic_statistics_without_errors.append(line)
@@ -152,16 +154,13 @@ def get_data_dict_from_statistics_content(
         try:
             request_size_bytes = line['request_size_bytes']
             response_size_bytes = line['response_size_bytes']
-            if request_size_bytes == '':
-                request_size_bytes = '0'
-            if response_size_bytes == '':
-                response_size_bytes = '0'
-
-            hosts_requests_responses[type_to_check]['request_sizes'].append(int(request_size_bytes))
-            hosts_requests_responses[type_to_check]['response_sizes'].append(int(response_size_bytes))
-        except ValueError:
+            if request_size_bytes != '':
+                hosts_requests_responses[type_to_check]['request_sizes'].append(int(request_size_bytes))
+            if response_size_bytes != '':
+                hosts_requests_responses[type_to_check]['response_sizes'].append(int(response_size_bytes))
+        except ValueError as e:
             print_api(line, color='yellow')
-            raise
+            raise e
 
     return hosts_requests_responses
 
@@ -175,13 +174,15 @@ def compute_statistics_from_data_dict(data_dict: dict):
     """
 
     for host, host_dict in data_dict.items():
-        count = len(host_dict['request_sizes'])
-        avg_request_size = statistics.mean(host_dict['request_sizes']) if count > 0 else 0
-        median_request_size = statistics.median(host_dict['request_sizes']) if count > 0 else 0
-        avg_response_size = statistics.mean(host_dict['response_sizes']) if count > 0 else 0
-        median_response_size = statistics.median(host_dict['response_sizes']) if count > 0 else 0
-
-        data_dict[host]['count'] = count
+        count_requests = len(host_dict['request_sizes'])
+        count_responses = len(host_dict['response_sizes'])
+        avg_request_size = statistics.mean(host_dict['request_sizes']) if count_requests > 0 else 0
+        median_request_size = statistics.median(host_dict['request_sizes']) if count_requests > 0 else 0
+        avg_response_size = statistics.mean(host_dict['response_sizes']) if count_responses > 0 else 0
+        median_response_size = statistics.median(host_dict['response_sizes']) if count_responses > 0 else 0
+
+        data_dict[host]['count_requests'] = count_requests
+        data_dict[host]['count_responses'] = count_responses
         data_dict[host]['avg_request_size'] = avg_request_size
         data_dict[host]['median_request_size'] = median_request_size
         data_dict[host]['avg_response_size'] = avg_response_size
@@ -251,14 +252,16 @@ def compute_average_for_current_day_from_past_x_days(
         for host, host_dict in statistics_daily.items():
             if host not in moving_average:
                 moving_average[host] = {
-                    'counts': [],
+                    'all_request_counts': [],
+                    'all_response_counts': [],
                     'avg_request_sizes': [],
                     'avg_response_sizes': [],
                     'median_request_sizes': [],
                     'median_response_sizes': []
                 }
 
-            moving_average[host]['counts'].append(int(host_dict['count']))
+            moving_average[host]['all_request_counts'].append(int(host_dict['count_requests']))
+            moving_average[host]['all_response_counts'].append(int(host_dict['count_responses']))
             moving_average[host]['avg_request_sizes'].append(float(host_dict['avg_request_size']))
             moving_average[host]['avg_response_sizes'].append(float(host_dict['avg_response_size']))
             moving_average[host]['median_request_sizes'].append(float(host_dict['median_request_size']))
@@ -267,21 +270,26 @@ def compute_average_for_current_day_from_past_x_days(
     # Compute the moving average.
     moving_average_results: dict = {}
     for host, host_dict in moving_average.items():
-        ma_count = statistics.mean(host_dict['counts'])
+        ma_request_count = statistics.mean(host_dict['all_request_counts'])
+        ma_response_count = statistics.mean(host_dict['all_response_counts'])
         ma_request_size = statistics.mean(host_dict['avg_request_sizes'])
         ma_response_size = statistics.mean(host_dict['avg_response_sizes'])
-        mm_count = statistics.median(host_dict['counts'])
+        mm_request_count = statistics.median(host_dict['all_request_counts'])
+        mm_response_count = statistics.median(host_dict['all_response_counts'])
         mm_request_size = statistics.median(host_dict['median_request_sizes'])
         mm_response_size = statistics.median(host_dict['median_response_sizes'])
 
         moving_average_results[host] = {
-            'ma_count': ma_count,
+            'ma_request_count': ma_request_count,
+            'ma_response_count': ma_response_count,
             'ma_request_size': ma_request_size,
             'ma_response_size': ma_response_size,
-            'mm_count': mm_count,
+            'mm_request_count': mm_request_count,
+            'mm_response_count': mm_response_count,
             'mm_request_size': mm_request_size,
             'mm_response_size': mm_response_size,
-            'counts': host_dict['counts'],
+            'all_request_counts': host_dict['all_request_counts'],
+            'all_response_counts': host_dict['all_response_counts'],
             'avg_request_sizes': host_dict['avg_request_sizes'],
             'avg_response_sizes': host_dict['avg_response_sizes'],
             'median_request_sizes': host_dict['median_request_sizes'],
@@ -293,7 +301,8 @@ def compute_average_for_current_day_from_past_x_days(
 
 def find_deviation_from_moving_average(
         statistics_content: dict,
-        top_bottom_deviation_percentage: float
+        top_bottom_deviation_percentage: float,
+        skip_total_count_less_than: int = None
 ) -> list:
     """
     This function finds the deviation from the moving average to the bottom or top by specified percentage.
@@ -301,12 +310,13 @@ def find_deviation_from_moving_average(
     :param statistics_content: dict, the statistics content dictionary.
     :param top_bottom_deviation_percentage: float, the percentage of deviation from the moving average to the top or
         bottom.
+    :param skip_total_count_less_than: integer, if the total count is less than this number, skip the deviation.
     :return: list, the deviation list.
     """
 
     def _check_deviation(
-            check_type: Literal['count', 'avg_request_size', 'avg_response_size'],
-            ma_check_type: Literal['ma_count', 'ma_request_size', 'ma_response_size'],
+            check: Literal['count', 'avg'],
+            traffic_direction: Literal['request', 'response'],
             day_statistics_content_dict: dict,
             moving_averages_dict: dict
     ):
@@ -316,6 +326,19 @@ def find_deviation_from_moving_average(
 
         nonlocal message
 
+        if check == 'count':
+            check_type = f'{check}_{traffic_direction}s'
+            ma_check_type = f'ma_{traffic_direction}_{check}'
+            median_type_string = check_type
+            moving_median_type_string = f'mm_{traffic_direction}_{check}'
+        elif check == 'avg':
+            check_type = f'{check}_{traffic_direction}_size'
+            ma_check_type = f'ma_{traffic_direction}_size'
+            median_type_string = f'median_{traffic_direction}_size'
+            moving_median_type_string = f'mm_{traffic_direction}_size'
+        else:
+            raise ValueError(f'Invalid check: {check}')
+
         host_moving_average_by_type = moving_averages_dict[host][ma_check_type]
         check_type_moving_by_percent = (
                 host_moving_average_by_type * top_bottom_deviation_percentage)
@@ -338,29 +361,32 @@ def find_deviation_from_moving_average(
         if deviation_type:
             message = f'[{check_type}] is [{deviation_type}] the moving average.'
 
-            # Get the right moving median.
-            if check_type == 'count':
-                median_type_string: str = 'count'
-                moving_median_type_string: str = 'mm_count'
-            else:
-                median_type_string: str = check_type.replace('avg', 'median')
-                moving_median_type_string: str = check_type.replace('avg', 'mm')
-
             # The median and the total count are None for the count, Since they are the count.
-            if check_type == 'count':
+            if 'count' in check_type:
                 total_entries_averaged = None
                 median_size = None
             else:
-                total_entries_averaged = day_statistics_content_dict['count']
+                total_entries_averaged = day_statistics_content_dict[f'count_{traffic_direction}s']
                 median_size = day_statistics_content_dict[median_type_string]
 
+            value = day_statistics_content_dict[check_type]
+
+            # If the total count is less than the specified number, skip the deviation.
+            if skip_total_count_less_than:
+                if total_entries_averaged:
+                    if total_entries_averaged < skip_total_count_less_than:
+                        return
+                else:
+                    if value < skip_total_count_less_than:
+                        return
+
             moving_median_size = moving_averages_dict[host][moving_median_type_string]
 
             deviation_list.append({
                 'day': day,
                 'host': host,
                 'message': message,
-                'value': day_statistics_content_dict[check_type],
+                'value': value,
                 'ma_value': host_moving_average_by_type,
                 'check_type': check_type,
                 'percentage': top_bottom_deviation_percentage,
@@ -411,10 +437,12 @@ def find_deviation_from_moving_average(
                 continue
 
             _check_deviation(
-                'count', 'ma_count', host_dict, previous_day_moving_average_dict)
+                'count', 'request', host_dict, previous_day_moving_average_dict)
+            _check_deviation(
+                'count', 'response', host_dict, previous_day_moving_average_dict)
             _check_deviation(
-                'avg_request_size', 'ma_request_size', host_dict, previous_day_moving_average_dict)
+                'avg', 'request', host_dict, previous_day_moving_average_dict)
             _check_deviation(
-                'avg_response_size', 'ma_response_size', host_dict, previous_day_moving_average_dict)
+                'avg', 'response', host_dict, previous_day_moving_average_dict)
 
     return deviation_list

atomicshop/print_api.py

@@ -2,7 +2,6 @@ import sys
 import logging
 
 from .basics import ansi_escape_codes
-from .wrappers.loggingw import loggingw
 from .basics import tracebacks
 
 
@@ -74,6 +73,7 @@ def print_api(
 
     # Inner functions already get all the local variables of the main function.
     def print_or_logger():
+        from .wrappers.loggingw import loggingw
         nonlocal message
         nonlocal color
         nonlocal traceback_string
@@ -128,7 +128,6 @@ def print_api(
             if print_end == '\n':
                 if stdcolor and color is not None:
                     # Use logger to output message.
-                    # with loggingw.temporary_change_logger_stream_handler_color(logger, color=color):
                     with loggingw.temporary_change_logger_stream_handler_emit_color(logger, color):
                         getattr(logger, logger_method)(message)
                 else: