atomicshop 2.16.27__py3-none-any.whl → 2.16.29__py3-none-any.whl

atomicshop/mitm/mitm_main.py

@@ -1,4 +1,3 @@
-import logging
 import threading
 import multiprocessing
 import time
@@ -6,12 +5,11 @@ import datetime
 
 import atomicshop   # Importing atomicshop package to get the version of the package.
 
-from .. import filesystem, queues, dns, on_exit
+from .. import filesystem, queues, dns, on_exit, print_api
 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 ..print_api import print_api
 
 from .initialize_engines import ModuleCategory
 from .connection_thread_worker import thread_worker_main
@@ -33,14 +31,14 @@ MITM_ERROR_LOGGER: loggingw.ExceptionCsvLogger = None
 def exit_cleanup():
     if permissions.is_admin():
         is_dns_dynamic, current_dns_gateway = dns.get_default_dns_gateway()
-        print_api(f'Current DNS Gateway: {current_dns_gateway}')
+        print_api.print_api(f'Current DNS Gateway: {current_dns_gateway}')
 
         if is_dns_dynamic != NETWORK_INTERFACE_IS_DYNAMIC or \
                 (not is_dns_dynamic and current_dns_gateway != NETWORK_INTERFACE_IPV4_ADDRESS_LIST):
             dns.set_connection_dns_gateway_dynamic(use_default_connection=True)
-            print_api("Returned default DNS gateway...", color='blue')
+            print_api.print_api("Returned default DNS gateway...", color='blue')
 
-    print_api(RECS_PROCESS_INSTANCE.is_alive())
+    print_api.print_api(RECS_PROCESS_INSTANCE.is_alive())
     RECS_PROCESS_INSTANCE.terminate()
     RECS_PROCESS_INSTANCE.join()
 
@@ -59,7 +57,8 @@ def mitm_server(config_file_path: str):
         return result
 
     global MITM_ERROR_LOGGER
-    MITM_ERROR_LOGGER = loggingw.ExceptionCsvLogger(EXCEPTIONS_CSV_LOGGER_NAME, config_static.LogRec.logs_path)
+    MITM_ERROR_LOGGER = loggingw.ExceptionCsvLogger(
+        logger_name=EXCEPTIONS_CSV_LOGGER_NAME, directory_path=config_static.LogRec.logs_path)
 
     # Create folders.
     filesystem.create_directory(config_static.LogRec.logs_path)
@@ -159,70 +158,72 @@ def mitm_server(config_file_path: str):
     # === EOF Initialize Reference Module ==========================================================================
     # === Engine logging ===========================================================================================
     # Printing the parsers using "start=1" for index to start counting from "1" and not "0"
-    print_api(f"[*] Found Engines:", logger=system_logger)
+    print_api.print_api(f"[*] Found Engines:", logger=system_logger)
     for index, engine in enumerate(engines_list, start=1):
         message = f"[*] {index}: {engine.engine_name} | {engine.domain_list}"
-        print_api(message, logger=system_logger)
+        print_api.print_api(message, logger=system_logger)
 
         message = (f"[*] Modules: {engine.parser_class_object.__name__}, "
                    f"{engine.responder_class_object.__name__}, "
                    f"{engine.recorder_class_object.__name__}")
-        print_api(message, logger=system_logger)
+        print_api.print_api(message, logger=system_logger)
 
     if config_static.DNSServer.enable:
-        print_api("DNS Server is enabled.", logger=system_logger)
+        print_api.print_api("DNS Server is enabled.", logger=system_logger)
 
         # If engines were found and dns is set to route by the engine domains.
         if engines_list and config_static.DNSServer.resolve_to_tcp_server_only_engine_domains:
-            print_api("Engine domains will be routed by the DNS server to Built-in TCP Server.", logger=system_logger)
+            print_api.print_api(
+                "Engine domains will be routed by the DNS server to Built-in TCP Server.", logger=system_logger)
         # If engines were found, but the dns isn't set to route to engines.
         elif engines_list and not config_static.DNSServer.resolve_to_tcp_server_only_engine_domains:
             message = f"[*] Engine domains found, but the DNS routing is set not to use them for routing."
-            print_api(message, color="yellow", logger=system_logger)
+            print_api.print_api(message, color="yellow", logger=system_logger)
         elif not engines_list and config_static.DNSServer.resolve_to_tcp_server_only_engine_domains:
             error_message = (
                 f"No engines were found in: [{config_static.MainConfig.ENGINES_DIRECTORY_PATH}]\n"
                 f"But the DNS routing is set to use them for routing.\n"
                 f"Please check your DNS configuration in the 'config.ini' file.")
-            print_api(error_message, color="red")
+            print_api.print_api(error_message, color="red")
             return 1
 
         if config_static.DNSServer.resolve_to_tcp_server_all_domains:
-            print_api("All domains will be routed by the DNS server to Built-in TCP Server.", logger=system_logger)
+            print_api.print_api(
+                "All domains will be routed by the DNS server to Built-in TCP Server.", logger=system_logger)
 
         if config_static.DNSServer.resolve_regular:
-            print_api(
+            print_api.print_api(
                 "Regular DNS resolving is enabled. Built-in TCP server will not be routed to",
                 logger=system_logger, color="yellow")
     else:
-        print_api("DNS Server is disabled.", logger=system_logger, color="yellow")
+        print_api.print_api("DNS Server is disabled.", logger=system_logger, color="yellow")
 
     if config_static.TCPServer.enable:
-        print_api("TCP Server is enabled.", logger=system_logger)
+        print_api.print_api("TCP Server is enabled.", logger=system_logger)
 
         if engines_list and not config_static.TCPServer.engines_usage:
             message = \
                 f"Engines found, but the TCP server is set not to use them for processing. General responses only."
-            print_api(message, color="yellow", logger=system_logger)
+            print_api.print_api(message, color="yellow", logger=system_logger)
         elif engines_list and config_static.TCPServer.engines_usage:
             message = f"Engines found, and the TCP server is set to use them for processing."
-            print_api(message, logger=system_logger)
+            print_api.print_api(message, logger=system_logger)
         elif not engines_list and config_static.TCPServer.engines_usage:
             error_message = (
                 f"No engines were found in: [{config_static.MainConfig.ENGINES_DIRECTORY_PATH}]\n"
                 f"But the TCP server is set to use them for processing.\n"
                 f"Please check your TCP configuration in the 'config.ini' file.")
-            print_api(error_message, color="red")
+            print_api.print_api(error_message, color="red")
             return 1
     else:
-        print_api("TCP Server is disabled.", logger=system_logger, color="yellow")
+        print_api.print_api("TCP Server is disabled.", logger=system_logger, color="yellow")
 
     # === EOF Engine Logging =======================================================================================
 
     # Assigning all the engines domains to all time domains, that will be responsible for adding new domains.
     config_static.Certificates.domains_all_times = list(domains_engine_list_full)
 
-    print_api("Press [Ctrl]+[C] to stop.", color='blue')
+    print_api.print_api("Press [Ctrl]+[C] to stop.", color='blue')
 
     # Create request domain queue.
     domain_queue = queues.NonBlockQueue()
@@ -250,7 +251,7 @@ def mitm_server(config_file_path: str):
                 logger=network_logger
             )
         except (dns_server.DnsPortInUseError, dns_server.DnsConfigurationValuesError) as e:
-            print_api(e, error_type=True, color="red", logger=system_logger)
+            print_api.print_api(e, error_type=True, color="red", logger=system_logger)
             # Wait for the message to be printed and saved to file.
             time.sleep(1)
             return 1
@@ -296,6 +297,7 @@ def mitm_server(config_file_path: str):
                 ssh_pass=config_static.ProcessName.ssh_pass,
                 ssh_script_to_execute=config_static.ProcessName.ssh_script_to_execute,
                 logger=listener_logger,
+                exceptions_logger=MITM_ERROR_LOGGER,
                 statistics_logs_directory=config_static.LogRec.logs_path,
                 forwarding_dns_service_ipv4_list___only_for_localhost=(
                     config_static.TCPServer.forwarding_dns_service_ipv4_list___only_for_localhost),
@@ -303,12 +305,12 @@ def mitm_server(config_file_path: str):
                 request_domain_from_dns_server_queue=domain_queue
             )
         except socket_wrapper.SocketWrapperPortInUseError as e:
-            print_api(e, error_type=True, color="red", logger=system_logger)
+            print_api.print_api(e, error_type=True, color="red", logger=system_logger)
             # Wait for the message to be printed and saved to file.
             time.sleep(1)
             return 1
         except socket_wrapper.SocketWrapperConfigurationValuesError as e:
-            print_api(e, error_type=True, color="red", logger=system_logger, logger_method='critical')
+            print_api.print_api(e, error_type=True, color="red", logger=system_logger, logger_method='critical')
             # Wait for the message to be printed and saved to file.
             time.sleep(1)
             return 1
@@ -386,7 +388,7 @@ def mitm_server_main(config_file_path: str):
         # Main function should return integer with error code, 0 is successful.
         return mitm_server(config_file_path)
     except KeyboardInterrupt:
-        print_api("Server Stopped by [KeyboardInterrupt].", color='blue')
+        print_api.print_api("Server Stopped by [KeyboardInterrupt].", color='blue')
         exit_cleanup()
         return 0
     except Exception as e:

atomicshop/print_api.py

@@ -1,18 +1,18 @@
 import sys
 import logging
 
-from .basics.ansi_escape_codes import ColorsBasic, get_colors_basic_dict
+from .basics import ansi_escape_codes
+from .wrappers.loggingw import loggingw
 from .basics import tracebacks
 
 
-# noinspection PyUnusedLocal,PyIncorrectDocstring
 def print_api(
         message: any,
         color: any = None,
         print_end: str = '\n',
         rtl: bool = False,
         error_type: bool = False,
-        logger: object = None,
+        logger: logging.Logger = None,
         logger_method: str = 'info',
         stdout: bool = True,
         stderr: bool = True,
@@ -20,8 +20,6 @@ def print_api(
         traceback_string: bool = False,
         oneline: bool = False,
         oneline_end: str = '',
-        # raise_exception: bool = True,
-        # exit_on_error: bool = False,
         **kwargs: object) -> None:
     """
     Function of custom api that is responsible for printing messages to console.
@@ -83,10 +81,6 @@ def print_api(
 
         # This section takes care of different types of string manipulations for message.
 
-        # If 'exit_on_error' is set to 'True', we'll add 'exit_message' on new line after 'message'.
-        # if error_type and exit_on_error and raise_exception:
-        #     message = message + '\n' + exit_message
-
         # If 'rtl' is set to 'True', we'll add Right-To-Left text conversion to 'message'.
         if rtl:
             # Lazy importing of 'bidi' library. It's not a problem since python caches the library after first import.
@@ -118,22 +112,8 @@ def print_api(
             elif logger_method == 'critical' and not color:
                 color = 'red'
 
-            if color and not logger:
-                message = get_colors_basic_dict(color) + message + ColorsBasic.END
-            elif color and logger:
-                # Save the original formatter
-                original_formatter = None
-
-                # Find the stream handler and change its formatter
-                for handler in logger.handlers:
-                    if isinstance(handler, logging.StreamHandler):
-                        # Save the original formatter
-                        original_formatter = handler.formatter
-
-                        # Create a colored formatter for errors
-                        color_formatter = logging.Formatter(
-                            get_colors_basic_dict(color) + original_formatter + ColorsBasic.END)
-                        handler.setFormatter(color_formatter)
+            if color is not None and logger is None:
+                message = ansi_escape_codes.get_colors_basic_dict(color) + message + ansi_escape_codes.ColorsBasic.END
 
         # If 'online' is set to 'True', we'll output message as oneline.
         if oneline:
@@ -146,22 +126,20 @@ def print_api(
         if logger:
             # Emit to logger only if 'print_end' is default, since we can't take responsibility for anything else.
             if print_end == '\n':
-                # Use logger to output message.
-                getattr(logger, logger_method)(message)
-
-            if stdcolor:
-                # Restore the original formatter after logging
-                for handler in logger.handlers:
-                    if isinstance(handler, logging.StreamHandler):
-                        handler.setFormatter(original_formatter)
+                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:
+                    # Use logger to output message.
+                    getattr(logger, logger_method)(message)
         # If logger wasn't passed.
         else:
             # Use print to output the message.
             print(message, end=print_end)
 
     # = Main Section with printing cases ===============================================================================
-    # exit_message: str = 'Exiting...'
-
     # Convert message to string.
     message = str(message)
 
@@ -175,20 +153,6 @@ def print_api(
         if error_type:
             print_or_logger()
 
-    # ==================================
-    # This section is responsible for ending the script.
-
-    # Check if we're inside exception. In this case each of 3 entries in 'sys.exc_info()' tuple will not equal
-    # to 'None', so picked only the first one.
-    # if sys.exc_info()[0] and not exit_on_error:
-    #     # If 'raise_exception' is set to 'True', we'll end the script with exception.
-    #     if pass_exception:
-    #         pass
-
-    # If 'exit_on_error' is set to 'True', we'll end the script.
-    # if exit_on_error and error_type:
-    #     sys.exit()
-
 
 def print_status(
         prefix_string: str,

atomicshop/system_resource_monitor.py

@@ -2,8 +2,7 @@ from typing import Union
 import threading
 import multiprocessing.managers
 
-from .print_api import print_api
-from . import system_resources
+from . import system_resources, print_api
 
 
 class SystemResourceMonitor:
@@ -109,7 +108,7 @@ class SystemResourceMonitor:
         self.thread: Union[threading.Thread, None] = None
         # Sets the running state of the monitoring process. Needed to stop the monitoring and queue threads.
         self.running: bool = False
-        # The shared results dictionary.
+        # The shared results' dictionary.
         self.results: dict = {}
 
     def start(self, print_kwargs: dict = None):
@@ -128,7 +127,8 @@ class SystemResourceMonitor:
             """
 
             while self.running:
-                # Get the results of the system resources check function and store them in temporary results dictionary.
+                # Get the results of the system resources check function and store them in
+                # temporary results' dictionary.
                 results = system_resources.check_system_resources(
                     interval=interval, get_cpu=get_cpu, get_memory=get_memory,
                     get_disk_io_bytes=get_disk_io_bytes, get_disk_files_count=get_disk_files_count,
@@ -149,9 +149,9 @@ class SystemResourceMonitor:
                     for queue in queue_list:
                         queue.put(results)
 
-                # Update the shared results dictionary with the temporary results dictionary.
+                # Update the shared results dictionary with the temporary results' dictionary.
                 # This is done in separate steps to avoid overwriting the special 'multiprocessing.Manager.dict' object.
-                # So we update the shared results dictionary with the temporary results dictionary.
+                # So we update the shared results dictionary with the temporary results' dictionary.
                 if manager_dict is not None:
                     manager_dict.update(results)
 
@@ -169,7 +169,7 @@ class SystemResourceMonitor:
             self.thread.daemon = True
             self.thread.start()
         else:
-            print_api("Monitoring is already running.", color='yellow', **print_kwargs)
+            print_api.print_api("Monitoring is already running.", color='yellow', **print_kwargs)
 
     def get_results(self) -> dict:
         """
@@ -258,7 +258,7 @@ def start_monitoring(
         )
         SYSTEM_RESOURCES_MONITOR.start()
     else:
-        print_api("System resources monitoring is already running.", color='yellow', **(print_kwargs or {}))
+        print_api.print_api("System resources monitoring is already running.", color='yellow', **(print_kwargs or {}))
 
 
 def stop_monitoring():

atomicshop/system_resources.py

@@ -5,9 +5,8 @@ import shutil
 import threading
 import multiprocessing.managers
 
-from .print_api import print_api
 from .wrappers.psutilw import cpus, memories, disks
-from . import system_resource_monitor
+from . import system_resource_monitor, print_api
 
 
 def check_system_resources(
@@ -129,13 +128,13 @@ def wait_for_resource_availability(
 
         if result['cpu_usage'] < cpu_percent_max and result['memory_usage'] < memory_percent_max:
             break
-        print_api(
+        print_api.print_api(
             f"Waiting for resources to be available... "
             f"CPU: {result['cpu_usage']}%, Memory: {result['memory_usage']}%", color='yellow')
         time.sleep(wait_time)  # Wait for 'wait_time' seconds before checking again
 
 
-def test_disk_speed_with_monitoring(
+def _test_disk_speed_with_monitoring(
         file_settings: list[dict],
         remove_file_after_each_copy: bool = False,
         target_directory=None,
@@ -144,6 +143,7 @@ def test_disk_speed_with_monitoring(
         print_kwargs: dict = None
 ):
     """
+    THIS IS NOT TESTED.
     Generates files and performs write and read operations in the specified target directory,
     while monitoring disk I/O speeds in a separate thread. Returns the maximum read and write rates,
     and the total operation time.
@@ -171,7 +171,7 @@ def test_disk_speed_with_monitoring(
     if monitoring:
         system_resource_monitor.start_monitoring(
             interval=1, get_cpu=False, get_memory=False, get_disk_io_bytes=True, get_disk_used_percent=False,
-            get_disk_files_count=True, calculate_maximum_changed_disk_io=True, use_queue=True)
+            get_disk_files_count=True, calculate_maximum_changed_disk_io=True)
 
     if target_directory is None:
         target_directory = tempfile.mkdtemp()
@@ -196,7 +196,7 @@ def test_disk_speed_with_monitoring(
             shutil.copy(src_file_path, dest_directory)
 
             target_file_path = os.path.join(dest_directory, os.path.basename(src_file_path))
-            print_api(f"Copied: {target_file_path}", **(print_kwargs or {}))
+            print_api.print_api(f"Copied: {target_file_path}", **(print_kwargs or {}))
 
             # Measure read speed.
             with open(target_file_path, "rb") as file:
@@ -212,7 +212,7 @@ def test_disk_speed_with_monitoring(
 
     overall_end_time = time.time()
     total_execution_time = overall_end_time - overall_start_time
-    print_api(f"Total execution time: {total_execution_time}", **(print_kwargs or {}))
+    print_api.print_api(f"Total execution time: {total_execution_time}", **(print_kwargs or {}))
 
     # Cleanup. Remove all created files and directories.
     shutil.rmtree(source_directory)
@@ -220,7 +220,7 @@ def test_disk_speed_with_monitoring(
 
     if monitoring:
         # Stop the I/O monitoring.
-        max_io_changes = system_resource_monitor.get_result()['maximum_disk_io']
+        max_io_changes = system_resource_monitor.get_results()['maximum_disk_io']
         system_resource_monitor.stop_monitoring()
 
     return total_execution_time, max_io_changes

atomicshop/web.py

@@ -1,14 +1,14 @@
 import os
 import urllib.request
 import ssl
+# noinspection PyPackageRequirements
 import certifi
 
-from .print_api import print_api
 from .archiver import zips
 from .urls import url_parser
 from .file_io import file_io
 from .wrappers.playwrightw import scenarios
-from . import filesystem
+from . import filesystem, print_api
 
 
 # https://www.useragents.me/
@@ -28,10 +28,10 @@ def is_status_ok(status_code: int, **kwargs) -> bool:
     """
 
     if status_code != 200:
-        print_api(f'URL Error, status code: {str(status_code)}', error_type=True, **kwargs)
+        print_api.print_api(f'URL Error, status code: {str(status_code)}', error_type=True, **kwargs)
         return False
     else:
-        print_api('URL Status: 200 OK', color="green", **kwargs)
+        print_api.print_api('URL Status: 200 OK', color="green", **kwargs)
         return True
 
 
@@ -165,10 +165,10 @@ def download(
 
     def print_to_console(print_end=None):
         if file_size_bytes_int:
-            print_api(
+            print_api.print_api(
                 f'Downloaded bytes: {aggregated_bytes_int} / {file_size_bytes_int}', print_end=print_end, **kwargs)
         else:
-            print_api(f'Downloaded bytes: {aggregated_bytes_int}', print_end=print_end, **kwargs)
+            print_api.print_api(f'Downloaded bytes: {aggregated_bytes_int}', print_end=print_end, **kwargs)
 
     # Size of the buffer to read each time from url.
     buffer_size: int = 4096
@@ -185,8 +185,8 @@ def download(
     # Build full path to file.
     file_path: str = f'{target_directory}{os.sep}{file_name}'
 
-    print_api(f'Downloading: {file_url}', **kwargs)
-    print_api(f'To: {file_path}', **kwargs)
+    print_api.print_api(f'Downloading: {file_url}', **kwargs)
+    print_api.print_api(f'To: {file_path}', **kwargs)
 
     # In order to use 'urllib.request', it is not enough to 'import urllib', you need to 'import urllib.request'.
     # Open the URL for data gathering with SSL context from certifi
@@ -223,10 +223,10 @@ def download(
                 print_to_console()
                 break
     if aggregated_bytes_int == file_size_bytes_int:
-        print_api(f'Successfully Downloaded to: {file_path}', color="green", **kwargs)
+        print_api.print_api(f'Successfully Downloaded to: {file_path}', color="green", **kwargs)
     else:
         message = f'Download failed: {aggregated_bytes_int} / {file_size_bytes_int}. File: {file_path}'
-        print_api(
+        print_api.print_api(
             message, error_type=True, color="red", **kwargs)
 
     return file_path

atomicshop/wrappers/loggingw/filters.py

@@ -1,12 +1,18 @@
 import logging
+import threading
 import os
 
 
+from ...basics import ansi_escape_codes
+
+
 class HeaderFilter(logging.Filter):
     """
     A logging.Filter that writes a header to a log file if the file is empty (
     i.e., no log records have been written, i.e.2, on file rotation).
     """
+
+    # noinspection PyPep8Naming
     def __init__(self, header, baseFilename):
         super().__init__()
         self.header = header
@@ -27,6 +33,23 @@ class HeaderFilter(logging.Filter):
         return True
 
 
+class ThreadColorLogFilter(logging.Filter):
+    """
+    A logging.Filter that adds color to log records based on the thread that emitted the log record.
+    """
+    def __init__(self, color: str, thread_id):
+        super().__init__()
+        self.color = color
+        self.thread_id = thread_id
+
+    def filter(self, record):
+        if threading.get_ident() == self.thread_id:
+            record.msg = (
+                    ansi_escape_codes.get_colors_basic_dict(self.color) + record.msg +
+                    ansi_escape_codes.ColorsBasic.END)
+        return True
+
+
 """
 A logging.Filter in Python's logging module is an object that provides a way to perform fine-grained 
 filtering of log records. 

atomicshop/wrappers/loggingw/formatters.py

@@ -155,3 +155,15 @@ def get_logging_formatter_from_string(
         return NanosecondsFormatter(formatter, style=style, datefmt=datefmt, use_nanoseconds=use_nanoseconds)
     else:
         return logging.Formatter(formatter, style=style, datefmt=datefmt)
+
+
+def get_formatter_string(formatter) -> str:
+    """
+    Function to get the formatter string from the 'logging.Formatter'.
+
+    :param formatter: logging.Formatter, formatter to convert to string.
+    :return: str, formatter string.
+    """
+
+    # noinspection PyProtectedMember
+    return formatter._fmt

atomicshop/wrappers/loggingw/handlers.py

@@ -8,6 +8,7 @@ import queue
 from typing import Literal, Union
 import threading
 from datetime import datetime
+import contextlib
 
 from . import loggers, formatters, filters, consts
 from ... import datetimes, filesystem
@@ -472,3 +473,32 @@ def add_filter_to_handler(handler: logging.Handler, filter_object: logging.Filte
     """
 
     handler.addFilter(filter_object)
+
+
+def get_formatter_string(handler: logging.Handler) -> str:
+    """
+    Function to get the formatter string from the handler.
+    :param handler: Handler to get the formatter from.
+    :return: Formatter string.
+    """
+
+    return formatters.get_formatter_string(handler.formatter)
+
+
+@contextlib.contextmanager
+def temporary_change_formatter(handler: logging.Handler, formatter_string: str):
+    """
+    Context manager to temporarily change the formatter of the handler.
+
+    Example:
+        with temporary_change_formatter(handler, formatter_string):
+            # Do something with the temporary formatter.
+            pass
+    """
+    original_formatter = handler.formatter
+
+    try:
+        handler.setFormatter(logging.Formatter(formatter_string))
+        yield
+    finally:
+        handler.setFormatter(original_formatter)