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

atomicshop/wrappers/loggingw/loggingw.py

@@ -2,11 +2,13 @@ import logging
 import os
 from typing import Literal, Union
 import datetime
+import contextlib
+import threading
 
 from . import loggers, handlers
 from ...file_io import csvs
-from ...basics import tracebacks
-from ...print_api import print_api
+from ...basics import tracebacks, ansi_escape_codes
+from ...import print_api
 
 
 class LoggingwLoggerAlreadyExistsError(Exception):
@@ -274,25 +276,146 @@ def is_logger_exists(logger_name: str) -> bool:
     return loggers.is_logger_exists(logger_name)
 
 
+def find_the_parent_logger_with_stream_handler(logger: logging.Logger) -> logging.Logger:
+    """
+    Function to find the parent logger with StreamHandler.
+    Example:
+        logger_name = "parent.child.grandchild"
+        'parent' logger has StreamHandler, but 'child' and 'grandchild' don't.
+        This function will return the 'parent' logger, since both 'child' and 'grandchild' will inherit the
+        StreamHandler from the 'parent' logger.
+
+    :param logger: Logger to find the parent logger with StreamHandler.
+    :return: Parent logger with StreamHandler.
+    """
+
+    # Start with current logger to see if it has a stream handler.
+    current_logger = logger
+    found: bool = False
+    while current_logger and not current_logger.handlers:
+        for handler in current_logger.handlers:
+            if isinstance(handler, logging.StreamHandler):
+                found = True
+                break
+
+        if not found:
+            # If the current logger doesn't have the stream handler, let's move to the parent.
+            current_logger = current_logger.parent
+
+    return current_logger
+
+
+@contextlib.contextmanager
+def _temporary_change_logger_stream_handler_color(logger: logging.Logger, color: str):
+    """
+    THIS IS ONLY FOR REFERENCE, for better result use the 'temporary_change_logger_stream_handler_emit_color' function.
+    If there are several threads that use this logger, there could be a problem, since unwanted messages
+    could be colored with the color of the other thread. 'temporary_change_logger_stream_handler_emit_color' is thread
+    safe and will color only the messages from the current thread.
+
+    Context manager to temporarily change the color of the logger's StreamHandler formatter.
+
+    Example:
+        with temporary_change_logger_stream_handler_color(logger, color):
+            # Do something with the temporary color.
+            pass
+    """
+
+    # Find the current or the topmost logger's StreamHandler.
+    # Could be that it is a child logger inherits its handlers from the parent.
+    logger_with_handlers = find_the_parent_logger_with_stream_handler(logger)
+
+    found_stream_handler = None
+    for handler in logger_with_handlers.handlers:
+        if isinstance(handler, logging.StreamHandler):
+            found_stream_handler = handler
+            break
+
+    # Save the original formatter
+    original_formatter = found_stream_handler.formatter
+    original_formatter_string = handlers.get_formatter_string(found_stream_handler)
+
+    # Create a colored formatter for errors
+    color_formatter = logging.Formatter(
+        ansi_escape_codes.get_colors_basic_dict(color) + original_formatter_string +
+        ansi_escape_codes.ColorsBasic.END)
+
+    # thread_id = threading.get_ident()
+    # color_filter = filters.ThreadColorLogFilter(color, thread_id)
+    # found_stream_handler.addFilter(color_filter)
+    try:
+        found_stream_handler.setFormatter(color_formatter)
+        yield
+    finally:
+        found_stream_handler.setFormatter(original_formatter)
+        # found_stream_handler.removeFilter(color_filter)
+
+
+# Thread-local storage to store color codes per thread
+thread_local = threading.local()
+
+
+@contextlib.contextmanager
+def temporary_change_logger_stream_handler_emit_color(logger: logging.Logger, color: str):
+    """Context manager to temporarily set the color code for log messages in the current thread."""
+
+    # Find the current or the topmost logger's StreamHandler.
+    # Could be that it is a child logger inherits its handlers from the parent.
+    logger_with_handlers = find_the_parent_logger_with_stream_handler(logger)
+
+    found_stream_handler = None
+    for handler in logger_with_handlers.handlers:
+        if isinstance(handler, logging.StreamHandler):
+            found_stream_handler = handler
+            break
+
+    # Save the original emit method of the stream handler
+    original_emit = found_stream_handler.emit
+
+    def emit_with_color(record):
+        original_msg = record.msg
+        # Check if the current thread has a color code
+        if getattr(thread_local, 'color', None):
+            record.msg = (
+                ansi_escape_codes.get_colors_basic_dict(color) + original_msg +
+                ansi_escape_codes.ColorsBasic.END)
+        original_emit(record)  # Call the original emit method
+        record.msg = original_msg  # Restore the original message for other handlers
+
+    # Replace the emit method with our custom method
+    found_stream_handler.emit = emit_with_color
+
+    # Set the color code in thread-local storage for this thread
+    thread_local.color = color
+
+    try:
+        yield
+    finally:
+        # Restore the original emit method after the context manager is exited
+        found_stream_handler.emit = original_emit
+        # Clear the color code from thread-local storage
+        thread_local.color = None
+
+
 class ExceptionCsvLogger:
     def __init__(
             self,
             logger_name: str,
-            custom_header: str = None,
-            directory_path: str = None
+            directory_path: str = None,
+            custom_header: str = None
     ):
         """
         Initialize the ExceptionCsvLogger object.
 
         :param logger_name: Name of the logger.
+        :param directory_path: Directory path where the log file will be saved.
+            You can leave it as None, but if the logger doesn't exist, you will get an exception.
         :param custom_header: Custom header to write to the log file.
             If None, the default header will be used: "timestamp,exception", since that what is written to the log file.
             If you want to add more columns to the csv file, you can provide a custom header:
                 "custom1,custom2,custom3".
             These will be added to the default header as:
                 "timestamp,custom1,custom2,custom3,exception".
-        :param directory_path: Directory path where the log file will be saved.
-            You can leave it as None, but if the logger doesn't exist, you will get an exception.
         """
 
         if custom_header:
@@ -352,7 +475,7 @@ class ExceptionCsvLogger:
         self.logger.info(output_csv_line)
 
         if stdout:
-            print_api('', error_type=True, color="red", traceback_string=True)
+            print_api.print_api('', error_type=True, color="red", traceback_string=True)
 
     def get_logger(self):
         return self.logger

atomicshop/wrappers/playwrightw/engine.py

@@ -5,11 +5,10 @@ import random
 import getpass
 from tempfile import gettempdir
 
-from ...print_api import print_api
 from ...keyboard_press import send_alt_tab
-from ... import filesystem
+from ... import filesystem, print_api
 
-# Web automation library.
+# noinspection PyPackageRequirements
 from playwright.sync_api import sync_playwright
 # Stealth options for playwright. External.
 from playwright_stealth import stealth_sync
@@ -242,7 +241,7 @@ class PlaywrightEngine:
         for i in range(element_count):
             string_current = string_current + element.nth(i).text_content()
 
-        print_api(f'Current element text of [{locator_string}]: {string_current}', rtl=True)
+        print_api.print_api(f'Current element text of [{locator_string}]: {string_current}', rtl=True)
 
         # If text from previous cycle isn't the same as text from current cycle, then put the new value to the
         # previous one and return 'True' since the text really changed.
@@ -312,7 +311,7 @@ class PlaywrightEngine:
         # Nullifying 'string_previous', so new loop will not have the same one as previous loop in case of error.
         self.string_previous = str()
 
-        print_api('Finished execution Time: ' + str(datetime.datetime.now()), **kwargs)
-        print_api('Waiting minutes: ' + str(time_to_sleep_minutes), **kwargs)
+        print_api.print_api('Finished execution Time: ' + str(datetime.datetime.now()), **kwargs)
+        print_api.print_api('Waiting minutes: ' + str(time_to_sleep_minutes), **kwargs)
         time.sleep(time_to_sleep_minutes * 60)
-        print_api('-----------------------------------------', **kwargs)
+        print_api.print_api('-----------------------------------------', **kwargs)

atomicshop/wrappers/playwrightw/waits.py

@@ -1,7 +1,9 @@
-from atomicshop.print_api import print_api
+from ... import print_api
 
+# noinspection PyPackageRequirements
 from playwright.sync_api import expect
 # This is from official docs: https://playwright.dev/python/docs/api/class-timeouterror
+# noinspection PyPackageRequirements
 from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
 
 
@@ -124,7 +126,7 @@ def network_fully_idle(page, timeout: int = 2000, print_kwargs: dict = None) ->
             # 'page.expect_response' will wait for the response to be received, and then return the response object.
             # When timeout is reached, it will raise a TimeoutError, which will break the while loop.
             with page.expect_response("**/*", timeout=timeout) as response_info:
-                print_api(response_info.value, **print_kwargs)
+                print_api.print_api(response_info.value, **print_kwargs)
         except PlaywrightTimeoutError:
             break
 
@@ -151,13 +153,13 @@ def maximum_idle(page, print_kwargs: dict = None) -> None:
     :return: None
     """
 
-    print_api('Before wait_for_load', **print_kwargs)
+    print_api.print_api('Before wait_for_load', **print_kwargs)
     load(page)
-    print_api('After wait_for_load, Before wait_for_domcontentloaded', **print_kwargs)
+    print_api.print_api('After wait_for_load, Before wait_for_domcontentloaded', **print_kwargs)
     domcontentloaded(page)
-    print_api('After wait_for_domcontentloaded', **print_kwargs)
+    print_api.print_api('After wait_for_domcontentloaded', **print_kwargs)
     # For some reason 'networkidle' can result in timeout errors, so currently this is disabled.
     # networkidle(page)
-    print_api('Before wait_for_network_fully_idle', **print_kwargs)
+    print_api.print_api('Before wait_for_network_fully_idle', **print_kwargs)
     network_fully_idle(page, print_kwargs=print_kwargs)
-    print_api('After wait_for_network_fully_idle', **print_kwargs)
+    print_api.print_api('After wait_for_network_fully_idle', **print_kwargs)

atomicshop/wrappers/socketw/dns_server.py

@@ -317,7 +317,7 @@ class DnsServer:
 
         if self.resolve_to_tcp_server_all_domains:
             message = "Routing all domains to Built-in TCP Server."
-            print_api(message, logger=self.logger, color='green')
+            print_api(message, logger=self.logger, color='blue')
 
         if self.resolve_regular:
             message = f"Routing all domains to Live DNS Service: {self.forwarding_dns_service_ipv4}"

atomicshop/wrappers/socketw/sender.py

@@ -4,6 +4,7 @@ from pathlib import Path
 
 from ...print_api import print_api
 from ..loggingw import loggingw
+from ...basics import tracebacks
 
 
 class Sender:
@@ -29,18 +30,22 @@ class Sender:
         # until other side receives all, so there's no way knowing how much data was sent. Returns "None" on
         # Success though.
 
-        # Defining function result variable which will mean if the socket was closed or not.
-        # True means everything is fine
-        function_result: bool = True
+        # The error string that will be returned by the function in case of error.
+        # If returned None then everything is fine.
+        # noinspection PyTypeChecker
+        function_result_error: str = None
         # Current amount of bytes sent is 0, since we didn't start yet
         total_sent_bytes = 0
 
+        # noinspection PyTypeChecker
+        error_message: str = None
         try:
             # Getting byte length of current message
             current_message_length = len(self.class_message)
 
-            self.logger.info(f"Sending message to "
-                             f"{self.ssl_socket.getpeername()[0]}:{self.ssl_socket.getpeername()[1]}")
+            self.logger.info(
+                f"Sending message to "
+                f"{self.ssl_socket.getpeername()[0]}:{self.ssl_socket.getpeername()[1]}")
 
             # Looping through "socket.send()" method while total sent bytes are less than message length
             while total_sent_bytes < current_message_length:
@@ -48,9 +53,11 @@ class Sender:
                 sent_bytes = self.ssl_socket.send(self.class_message[total_sent_bytes:])
                 # If there were only "0" bytes sent, then connection on the other side was terminated
                 if sent_bytes == 0:
-                    self.logger.info(f"Sent {sent_bytes} bytes - connection is down... Could send only "
-                                     f"{total_sent_bytes} bytes out of {current_message_length}. Closing socket...")
-                    function_result = False
+                    error_message = (
+                        f"Sent {sent_bytes} bytes - connection is down... Could send only "
+                        f"{total_sent_bytes} bytes out of {current_message_length}. Closing socket...")
+                    self.logger.info(error_message)
+                    function_result_error = error_message
                     break
 
                 # Adding amount of currently sent bytes to the total amount of bytes sent
@@ -59,23 +66,25 @@ class Sender:
 
             # At this point the sending loop finished successfully
             self.logger.info(f"Sent the message to destination.")
-        except ConnectionResetError:
-            message = "* Couldn't reach the server - Connection was reset. Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True)
-            # Since the connection is down, it will be handled in thread_worker_main
-            function_result = False
-            pass
-        except ssl.SSLEOFError:
-            message = "SSLError on send, Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
-            # Since the connection is down, it will be handled in thread_worker_main
-            function_result = False
-            pass
-        except ssl.SSLZeroReturnError:
-            message = "TLS/SSL connection has been closed (EOF), Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
-            # Since the connection is down, it will be handled in thread_worker_main
-            function_result = False
-            pass
+        except ConnectionResetError as e:
+            error_class_type = str(type(e)).replace("<class '", '').replace("'>", '')
+            exception_error = tracebacks.get_as_string(one_line=True)
+            error_message = (f"Socket Send: Error, Couldn't reach the server - Connection was reset | "
+                             f"{error_class_type}: {exception_error}")
+        except (ssl.SSLEOFError, ssl.SSLZeroReturnError, ssl.SSLWantWriteError, TimeoutError) as e:
+            error_class_type = str(type(e)).replace("<class '", '').replace("'>", '')
+            exception_error = tracebacks.get_as_string(one_line=True)
+            error_message = f"Socket Send: {error_class_type}: {exception_error}"
+        except Exception as e:
+            error_class_type = str(type(e)).replace("<class '", '').replace("'>", '')
+            exception_error = tracebacks.get_as_string(one_line=True)
+            if 'ssl' in error_class_type.lower():
+                error_message = f"Socket Send: SSL UNDOCUMENTED Exception: {error_class_type}{exception_error}"
+            else:
+                error_message = f"Socket Send: Error, UNDOCUMENTED Exception: {error_class_type}{exception_error}"
 
-        return function_result
+        if error_message:
+            print_api(error_message, logger=self.logger, logger_method='error')
+            function_result_error = error_message
+
+        return function_result_error

atomicshop/wrappers/socketw/socket_client.py

@@ -5,7 +5,10 @@ from typing import Literal, Union
 import logging
 from pathlib import Path
 
+# noinspection PyPackageRequirements
 from cryptography import x509
+# noinspection PyPackageRequirements
+import dns.resolver
 
 from . import creator
 from .receiver import Receiver
@@ -16,8 +19,6 @@ from ..loggingw import loggingw
 from ...print_api import print_api
 from ...file_io import file_io
 
-import dns.resolver
-
 
 class SocketClient:
     def __init__(
@@ -221,12 +222,12 @@ class SocketClient:
                 f"[{self.service_name}] resolves to ip: [{self.connection_ip}]. Pulled IP from the socket.")
 
             # Send the data received from the client to the service over socket
-            function_data_sent = Sender(
+            error_on_send: str = Sender(
                 ssl_socket=self.socket_instance, class_message=request_bytes, logger=self.logger).send()
 
             # If the socket disconnected on data send
-            if not function_data_sent:
-                error_string = "Service socket closed on data send"
+            if error_on_send:
+                error_string = f"Service socket closed on data send: {error_on_send}"
 
                 # We'll close the socket and nullify the object
                 self.close_socket()

atomicshop/wrappers/socketw/socket_wrapper.py

@@ -2,6 +2,7 @@ import threading
 import select
 from typing import Literal, Union
 from pathlib import Path
+import logging
 
 from ..psutilw import networks
 from ..certauthw import certauthw
@@ -63,7 +64,8 @@ class SocketWrapper:
                 ],
                 None
             ] = None,
-            logger=None,
+            logger: logging.Logger = None,
+            exceptions_logger: loggingw.ExceptionCsvLogger = None,
             statistics_logs_directory: str = None,
             request_domain_from_dns_server_queue: queues.NonBlockQueue = None
     ):
@@ -144,7 +146,11 @@ class SocketWrapper:
         :param ssh_pass: string, SSH password that will be used to connect to remote host.
         :param ssh_script_to_execute: string, script that will be executed to get the process name on ssh remote host.
         :param logger: logging.Logger object, logger object that will be used to log messages.
-            If not provided, logger will be created with default settings.
+            If not provided, logger will be created with default settings saving logs to the
+            'statistics_logs_directory'.
+        :param exceptions_logger: loggingw.ExceptionCsvLogger object, logger object that will be used to log exceptions.
+            If not provided, logger will be created with default settings and will save exceptions to the
+            'statistics_logs_directory'.
         :param statistics_logs_directory: string, path to directory where daily statistics.csv files will be stored.
             After you initialize the SocketWrapper object, you can get the statistics_writer object from it and use it
             to write statistics to the file in a worker thread.
@@ -231,6 +237,14 @@ class SocketWrapper:
                 formatter_filehandler='DEFAULT'
             )
 
+        if not exceptions_logger:
+            self.exceptions_logger = loggingw.ExceptionCsvLogger(
+                logger_name='SocketWrapperExceptions',
+                directory_path=self.statistics_logs_directory
+            )
+        else:
+            self.exceptions_logger = exceptions_logger
+
         self.test_config()
 
     def test_config(self):
@@ -432,7 +446,8 @@ class SocketWrapper:
                 # Wait from any connection on "accept()".
                 # 'client_socket' is socket or ssl socket, 'client_address' is a tuple (ip_address, port).
                 client_socket, client_address, accept_error_message = accepter.accept_connection_with_error(
-                    listening_socket_object, domain_from_dns_server=domain_from_dns_server, print_kwargs={'logger': self.logger})
+                    listening_socket_object, domain_from_dns_server=domain_from_dns_server,
+                    print_kwargs={'logger': self.logger})
 
                 # This is the earliest stage to ask for process name.
                 # SSH Remote / LOCALHOST script execution to identify process section.
@@ -521,11 +536,15 @@ class SocketWrapper:
                     # If 'pass_function_reference_to_thread' was set to 'False', execute the callable passed function
                     # as is.
                     if not pass_function_reference_to_thread:
-                        reference_function_name(thread_args)
+                        before_socket_thread_worker(
+                            callable_function=reference_function_name, thread_args=thread_args,
+                            exception_logger=self.exceptions_logger)
                     # If 'pass_function_reference_to_thread' was set to 'True', execute the callable function reference
                     # in a new thread.
                     else:
-                        self._send_accepted_socket_to_thread(reference_function_name, thread_args)
+                        self._send_accepted_socket_to_thread(
+                            before_socket_thread_worker,
+                            reference_args=(reference_function_name, thread_args, self.exceptions_logger))
                 # Else, if no client_socket was opened during, accept, then print the error.
                 else:
                     # Write statistics after accept.
@@ -547,7 +566,26 @@ class SocketWrapper:
         # Append to list of threads, so they can be "joined" later
         self.threads_list.append(thread_current)
 
-        # 'reference_args[0]' is the client socket.
-        client_address = base.get_source_address_from_socket(reference_args[0])
+        # 'reference_args[1][0]' is the client socket.
+        client_address = base.get_source_address_from_socket(reference_args[1][0])
 
         self.logger.info(f"Accepted connection, thread created {client_address}. Continue listening...")
+
+
+def before_socket_thread_worker(
+        callable_function: callable,
+        thread_args: tuple,
+        exception_logger: loggingw.ExceptionCsvLogger = None
+):
+    """
+    Function that will be executed before the thread is started.
+    :param callable_function: callable, function that will be executed in the thread.
+    :param thread_args: tuple, arguments that will be passed to the function.
+    :param exception_logger: loggingw.ExceptionCsvLogger, logger object that will be used to log exceptions.
+    :return:
+    """
+
+    try:
+        callable_function(*thread_args)
+    except Exception as e:
+        exception_logger.write(e)

{atomicshop-2.16.28.dist-info → atomicshop-2.16.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.16.28
+Version: 2.16.29
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License: MIT License