atomicshop 2.16.42__py3-none-any.whl → 2.16.44__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.42'
+__version__ = '2.16.44'

atomicshop/basics/bytes_arrays.py

@@ -53,6 +53,30 @@ def convert_sequence_of_bytes_to_sequence_of_strings(byte_sequence: bytes) -> li
     return result
 
 
+def convert_sequence_of_bytes_to_exact_string(
+        byte_sequence: bytes,
+        add_space_between_bytes: bool = False,
+) -> str:
+    """
+    Convert sequence of bytes to exact string.
+    Example: b'\xc0\x00' -> 'c000'
+
+    :param byte_sequence: bytes, sequence of bytes.
+    :param add_space_between_bytes: bool, add space between bytes.
+        Example: b'\xc0\x00' -> 'c0 00'
+    :return: string.
+    """
+
+    # Convert to hex string and format
+    byte_list: list = []
+    for byte in byte_sequence:
+        byte_list.append(f'{byte:02x}')
+
+    result = ''.join(byte_list)
+
+    return result
+
+
 def find_position(target: bytes, file_path: str = None, file_bytes: bytes = None, chunk_size: int = None, starting_position: int = 0) -> int:
     """
     Find position of the target bytes string in the file.

atomicshop/dns.py

@@ -77,6 +77,17 @@ def get_default_dns_gateway() -> tuple[bool, list[str]]:
     return is_dynamic, dns_servers
 
 
+def get_default_dns_gateway_with_dns_resolver() -> list[str]:
+    """
+    Get the default DNS gateway from the system using dns.resolver.
+    :return: tuple(is dynamic boolean, list of DNS server IPv4s).
+    """
+
+    resolver = dns.resolver.Resolver()
+    dns_servers = list(resolver.nameservers)
+    return dns_servers
+
+
 def set_connection_dns_gateway_static(
         dns_servers: list[str],
         connection_name: str = None,

atomicshop/file_io/docxs.py

@@ -75,7 +75,7 @@ def search_for_hyperlink_in_files(directory_path: str, hyperlink: str, relative_
 
     # Get all the docx files in the specified directory.
     files = filesystem.get_paths_from_directory(
-        directory_path, get_file=True, file_name_check_pattern="*\.docx",
+        directory_path, get_file=True, file_name_check_pattern="*.docx",
         add_relative_directory=True, relative_file_name_as_directory=True)
 
     found_in_files: list = list()

atomicshop/http_parse.py

@@ -2,7 +2,6 @@ from http.server import BaseHTTPRequestHandler
 from http.client import HTTPResponse
 import http
 from io import BytesIO
-import socket
 
 
 class HTTPRequestParse(BaseHTTPRequestHandler):
@@ -50,8 +49,8 @@ class HTTPRequestParse(BaseHTTPRequestHandler):
     """
 
     # noinspection PyMissingConstructor
-    def __init__(self, request_text):
-        self.request_text = request_text
+    def __init__(self, request_bytes: bytes):
+        self.request_bytes: bytes = request_bytes
 
         # noinspection PyTypeChecker
         self.rfile = None
@@ -107,7 +106,7 @@ class HTTPRequestParse(BaseHTTPRequestHandler):
         error: str = str()
         info: str = str()
 
-        self.rfile = BytesIO(self.request_text)
+        self.rfile = BytesIO(self.request_bytes)
         self.raw_requestline = self.rfile.readline()
         self.error_code = self.error_message = None
         self.parse_request()
@@ -152,6 +151,7 @@ class FakeSocket:
     def __init__(self, response_bytes):
         self._file = BytesIO(response_bytes)
 
+    # noinspection PyUnusedLocal
     def makefile(self, mode='rb', buffering=-1) -> BytesIO:
         """
         Mimics the socket's makefile method, returning the BytesIO object.

atomicshop/mitm/connection_thread_worker.py

@@ -100,15 +100,12 @@ def thread_worker_main(
             client_message.protocol = 'HTTP'
             client_message.request_raw_decoded = request_decoded
             print_api(request_parsing_info, logger=network_logger, logger_method='info')
-            network_logger.info(f"Method: {request_decoded.command}")
-            network_logger.info(f"Path: {request_decoded.path}")
-        # If there was error - the request is really HTTP, but there's a problem with its structure.
+            network_logger.info(f"Method: {request_decoded.command} | Path: {request_decoded.path}")
         else:
-            # client_message.error = request_parsing_error
-            print_api(request_parsing_error, logger=network_logger, logger_method='error', color='yellow')
             # It doesn't matter if we have HTTP Parsing error, since the request may not be really HTTP, so it is OK
             # not to log it into statistics.
             # statistics_error_list.append(error_message)
+            print_api(request_parsing_error, logger=network_logger, logger_method='error', color='yellow')
 
     def finish_thread():
         # At this stage there could be several times that the same socket was used to the service server - we need to
@@ -204,8 +201,6 @@ def thread_worker_main(
                 client_message.request_raw_bytes = client_received_raw_data
 
                 parse_http()
-                if client_message.protocol != 'HTTP':
-                    pass
 
                 # Custom parser, should parse HTTP body or the whole message if not HTTP.
                 parser_instance = parser(client_message)

atomicshop/mitm/mitm_main.py

@@ -19,6 +19,7 @@ from . import config_static, recs_files
 
 NETWORK_INTERFACE_IS_DYNAMIC: bool = bool()
 NETWORK_INTERFACE_IPV4_ADDRESS_LIST: list[str] = list()
+IS_SET_DNS_GATEWAY: bool = False
 # noinspection PyTypeChecker
 RECS_PROCESS_INSTANCE: multiprocessing.Process = None
 
@@ -36,7 +37,7 @@ except win_console.NotWindowsConsoleError:
 
 
 def exit_cleanup():
-    if permissions.is_admin():
+    if permissions.is_admin() and IS_SET_DNS_GATEWAY:
         is_dns_dynamic, current_dns_gateway = dns.get_default_dns_gateway()
         status_string = 'Dynamic' if is_dns_dynamic else 'Static'
         print_api.print_api(f'Current DNS Gateway: {status_string}, {current_dns_gateway}')
@@ -347,10 +348,14 @@ def mitm_server(config_file_path: str):
             dns_gateway_server_list = [base.DEFAULT_IPV4]
             set_dns_gateway = True
 
-        # Get current network interface state.
-        global NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST
-        NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST = dns.get_default_dns_gateway()
         if set_dns_gateway:
+            global IS_SET_DNS_GATEWAY
+            IS_SET_DNS_GATEWAY = True
+
+            # Get current network interface state.
+            global NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST
+            NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST = dns.get_default_dns_gateway()
+
             # Set the DNS gateway to the specified one only if the DNS gateway is dynamic, or it is static but different
             # from the one specified in the configuration file.
             if (NETWORK_INTERFACE_IS_DYNAMIC or (not NETWORK_INTERFACE_IS_DYNAMIC and

atomicshop/web.py

@@ -90,10 +90,13 @@ def get_page_bytes(
 
 
 def get_page_content(
-        url: str, get_method: str = 'urllib', path: str = None,
+        url: str,
+        get_method: str = 'urllib',
+        path: str = None,
         playwright_pdf_format: str = 'A4',
         playwright_html_txt_convert_to_bytes: bool = True,
-        print_kwargs: dict = None) -> any:
+        print_kwargs: dict = None
+) -> any:
     """
     Function returns the page content from the given URL.
 

atomicshop/websocket_parse.py

@@ -0,0 +1,415 @@
+from typing import Union, Generator
+import logging
+
+from websockets.server import ServerProtocol
+from websockets.client import ClientProtocol
+from websockets.extensions.permessage_deflate import PerMessageDeflate, ServerPerMessageDeflateFactory, ClientPerMessageDeflateFactory
+from websockets.http11 import Request, Response
+from websockets.frames import Frame, Opcode
+from websockets.uri import parse_uri
+from websockets.exceptions import InvalidHeaderValue
+from websockets.protocol import OPEN
+from websockets.streams import StreamReader
+from websockets.exceptions import ProtocolError, PayloadTooBig
+
+
+class WebsocketParseWrongOpcode(Exception):
+    pass
+
+
+def create_byte_http_response(
+        byte_http_request: Union[bytes, bytearray],
+        enable_logging: bool = False
+) -> bytes:
+    """
+    Create a byte HTTP response from a byte HTTP request.
+
+    Parameters:
+    - byte_http_request (bytes, bytearray): The byte HTTP request.
+    - enable_logging (bool): Whether to enable logging.
+
+    Returns:
+    - bytes: The byte HTTP response.
+    """
+
+    # Set up extensions
+    permessage_deflate_factory = ServerPerMessageDeflateFactory()
+
+    # Create the protocol instance
+    protocol = ServerProtocol(
+        extensions=[permessage_deflate_factory],
+    )
+    # At this state the protocol.state is State.CONNECTING
+
+    if enable_logging:
+        logging.basicConfig(level=logging.DEBUG)
+        protocol.logger.setLevel(logging.DEBUG)
+
+
+    protocol.receive_data(byte_http_request)
+    events = protocol.events_received()
+    event = events[0]
+    if isinstance(event, Request):
+        # Accept the handshake.
+        # After the response is sent, it means the handshake was successful, the protocol.state is State.OPEN
+        # Only after this state we can parse frames.
+        response = protocol.accept(event)
+        return response.serialize()
+    else:
+        raise ValueError("The event is not a Request object.")
+
+
+def parse_frame_bytes(data_bytes: bytes):
+    # Define the read_exact function
+    def read_exact(n: int) -> Generator[None, None, bytes]:
+        return reader.read_exact(n)
+
+    # Helper function to run generator-based coroutines
+    def run_coroutine(coroutine):
+        try:
+            while True:
+                next(coroutine)
+        except StopIteration as e:
+            return e.value
+        except Exception as e:
+            raise e  # Re-raise exceptions to be handled by the caller
+
+    # Function to parse frames
+    def parse_frame(mask: bool):
+        try:
+            # Use Frame.parse to parse the frame
+            frame_parser = Frame.parse(
+                read_exact,
+                mask=mask,  # Client frames are masked
+                max_size=None,
+                extensions=[permessage_deflate],  # Include the extension unconditionally
+            )
+            current_frame = run_coroutine(frame_parser)
+        except EOFError as e:
+            # Not enough data to parse a complete frame
+            raise e
+        except (ProtocolError, PayloadTooBig) as e:
+            print("Error parsing frame:", e)
+            raise e
+        except Exception as e:
+            print("Error parsing frame:", e)
+            raise e
+        return current_frame
+
+    def process_frame(current_frame):
+        if current_frame.opcode == Opcode.TEXT:
+            message = current_frame.data.decode('utf-8', errors='replace')
+            return message
+        elif current_frame.opcode == Opcode.BINARY:
+            return current_frame.data
+        elif current_frame.opcode == Opcode.CLOSE:
+            print("Received close frame")
+        elif current_frame.opcode == Opcode.PING:
+            print("Received ping")
+        elif current_frame.opcode == Opcode.PONG:
+            print("Received pong")
+        else:
+            raise WebsocketParseWrongOpcode("Received unknown frame with opcode:", current_frame.opcode)
+
+    # Create the StreamReader instance
+    reader = StreamReader()
+
+    # Instantiate the permessage-deflate extension
+    permessage_deflate = PerMessageDeflate(
+        remote_no_context_takeover=False,
+        local_no_context_takeover=False,
+        remote_max_window_bits=15,
+        local_max_window_bits=15,
+    )
+
+    masked = is_frame_masked(data_bytes)
+
+    # Feed the data into the reader
+    reader.feed_data(data_bytes)
+
+    # Parse and process frames
+    frame = parse_frame(masked)
+    result = process_frame(frame)
+    return result
+
+
+def create_websocket_frame(
+            data: Union[str, bytes, bytearray],
+            deflate: bool = False,
+            mask: bool = False,
+            opcode: int = None
+    ) -> bytes:
+    """
+    Create a WebSocket frame with the given data, optionally applying
+    permessage-deflate compression and masking.
+
+    Parameters:
+    - data (str, bytes, bytearray): The payload data.
+        If str, it will be encoded to bytes using UTF-8.
+    - deflate (bool): Whether to apply permessage-deflate compression.
+    - mask (bool): Whether to apply masking to the frame.
+    - opcode (int): The opcode of the frame. If not provided, it will be
+        determined based on the type of data.
+        Example:
+            from websockets.frames import Opcode
+            Opcode.TEXT, Opcode.BINARY, Opcode.CLOSE, Opcode.PING, Opcode.PONG.
+
+    Returns:
+    - bytes: The serialized WebSocket frame ready to be sent.
+    """
+
+    # Determine the opcode if not provided
+    if opcode is None:
+        if isinstance(data, str):
+            opcode = Opcode.TEXT
+        elif isinstance(data, (bytes, bytearray)):
+            opcode = Opcode.BINARY
+        else:
+            raise TypeError("Data must be of type str, bytes, or bytearray.")
+    else:
+        if not isinstance(opcode, int):
+            raise TypeError("Opcode must be an integer.")
+        if not isinstance(data, (str, bytes, bytearray)):
+            raise TypeError("Data must be of type str, bytes, or bytearray.")
+
+    # Encode string data if necessary
+    if isinstance(data, str):
+        payload = data.encode('utf-8')
+    else:
+        payload = bytes(data)
+
+    # Create the Frame instance
+    frame = Frame(opcode=opcode, data=payload)
+
+    # Set up extensions if deflate is True
+    extensions = []
+    if deflate:
+        permessage_deflate = PerMessageDeflate(
+            remote_no_context_takeover=False,
+            local_no_context_takeover=False,
+            remote_max_window_bits=15,
+            local_max_window_bits=15,
+        )
+        extensions.append(permessage_deflate)
+
+    # Serialize the frame with the specified options
+    try:
+        frame_bytes = frame.serialize(
+            mask=mask,
+            extensions=extensions,
+        )
+    except Exception as e:
+        raise RuntimeError(f"Error serializing frame: {e}")
+
+    return frame_bytes
+
+
+def is_frame_masked(frame_bytes):
+    """
+    Determine whether a WebSocket frame is masked.
+
+    Parameters:
+    - frame_bytes (bytes): The raw bytes of the WebSocket frame.
+
+    Returns:
+    - bool: True if the frame is masked, False otherwise.
+    """
+    if len(frame_bytes) < 2:
+        raise ValueError("Frame is too short to determine masking.")
+
+    # The second byte of the frame header contains the MASK bit
+    second_byte = frame_bytes[1]
+
+    # The MASK bit is the most significant bit (MSB) of the second byte
+    mask_bit = (second_byte & 0x80) != 0  # 0x80 is 1000 0000 in binary
+
+    return mask_bit
+
+
+def is_frame_deflated(frame_bytes):
+    """
+    Determine whether a WebSocket frame is deflated (compressed).
+
+    Parameters:
+    - frame_bytes (bytes): The raw bytes of the WebSocket frame.
+
+    Returns:
+    - bool: True if the frame is deflated (compressed), False otherwise.
+    """
+    if len(frame_bytes) < 1:
+        raise ValueError("Frame is too short to determine deflation status.")
+
+    # The first byte of the frame header contains the RSV1 bit
+    first_byte = frame_bytes[0]
+
+    # The RSV1 bit is the second most significant bit (bit 6)
+    rsv1 = (first_byte & 0x40) != 0  # 0x40 is 0100 0000 in binary
+
+    return rsv1
+
+
+class _WebsocketRequestParse:
+    """
+    THIS IS ONLY FOR THE REFERENCE IT IS NOT CURRENTLY USED OR SHOULD BE USED.
+    Parse the websocket request and return the data
+    """
+    def __init__(
+            self,
+            enable_logging: bool = False,
+    ):
+        """
+        Initialize the websocket parser.
+
+        :param enable_logging: bool: Enable logging for the websocket protocol.
+        """
+        # noinspection PyTypeChecker
+        self.request_bytes: bytes = None
+
+        # Set up extensions
+        permessage_deflate_factory = ServerPerMessageDeflateFactory()
+
+        # Create the protocol instance
+        self.protocol = ServerProtocol(
+            extensions=[permessage_deflate_factory],
+        )
+        # At this state the protocol.state is State.CONNECTING
+
+        if enable_logging:
+            logging.basicConfig(level=logging.DEBUG)
+            self.protocol.logger.setLevel(logging.DEBUG)
+
+    def parse(
+            self,
+            request_bytes: bytes
+    ) -> Union[str, bytes, Request]:
+        """
+        Parse the websocket request and return the data
+
+        :param request_bytes: bytes: The raw bytes of the websocket request.
+        :return: Request: The parsed request object.
+        """
+
+        self.protocol.receive_data(request_bytes)
+        events = self.protocol.events_received()
+        for event in events:
+            if isinstance(event, Request):
+                # Accept the handshake.
+                # After the response is sent, it means the handshake was successful, the protocol.state is State.OPEN
+                # Only after this state we can parse frames.
+                response = self.protocol.accept(event)
+                self.protocol.send_response(response)
+                return event
+            elif isinstance(event, Frame):
+                frame = event
+                if frame.opcode == Opcode.TEXT:
+                    message = frame.data.decode('utf-8')
+                    return message
+                elif frame.opcode == Opcode.BINARY:
+                    return frame.data
+
+                """
+                # Handle control frames, these are here for the future references.
+                elif frame.opcode == Opcode.CLOSE:
+                    close_info = Close.parse(frame.data)
+                    print(f"Connection closed by client: {close_info.code}, {close_info.reason}")
+                    # Send a close frame in response if not already sent
+                    if self.protocol.state == self.protocol.OPEN:
+                        self.protocol.send_close()
+                elif frame.opcode == Opcode.PING:
+                    # Respond to ping with pong
+                    self.protocol.send_pong(frame.data)
+                elif frame.opcode == Opcode.PONG:
+                    print("Received pong")
+                """
+
+
+class _WebsocketResponseParse:
+    """
+    THIS IS ONLY FOR THE REFERENCE IT IS NOT CURRENTLY USED OR SHOULD BE USED.
+    Parse the websocket response and return the data
+    """
+    def __init__(
+            self,
+            enable_logging: bool = False,
+    ):
+        """
+        Initialize the websocket parser.
+
+        :param enable_logging: bool: Enable logging for the websocket protocol.
+        """
+        # noinspection PyTypeChecker
+        self.response_bytes: bytes = None
+
+        # Set up extensions
+        permessage_deflate_factory = ClientPerMessageDeflateFactory()
+
+        # Parse the WebSocket URI.
+        # Since we're parsing the response, we don't need the URI, but the protocol object requires it.
+        # So we will just use a dummy URI.
+        wsuri = parse_uri('ws://example.com/websocket')
+
+        # Create the protocol instance
+        self.protocol = ClientProtocol(
+            wsuri,
+            extensions=[permessage_deflate_factory],
+        )
+
+        if enable_logging:
+            logging.basicConfig(level=logging.DEBUG)
+            # self.protocol.logger.setLevel(logging.DEBUG)
+            self.protocol.debug = True
+
+        # Perform the handshake and emulate the connection and request sending.
+        request = self.protocol.connect()
+        self.protocol.send_request(request)
+        _ = self.protocol.data_to_send()
+        # At this state the protocol.state is State.CONNECTING
+
+    def parse(
+            self,
+            response_bytes: bytes
+    ) -> Union[str, bytes, Response]:
+        """
+        Parse the websocket response and return the data
+
+        :param response_bytes: bytes: The raw bytes of the websocket response.
+        :return: The parsed response.
+        """
+
+        self.protocol.receive_data(response_bytes)
+        events = self.protocol.events_received()
+        for event in events:
+            if isinstance(event, Response):
+                # Accept the handshake.
+                # After the response is sent, it means the handshake was successful, the protocol.state is State.OPEN
+                # Only after this state we can parse frames.
+                try:
+                    self.protocol.process_response(event)
+                except InvalidHeaderValue as e:
+                    headers = event.headers
+                    self.protocol.extensions = self.protocol.process_extensions(headers)
+                    self.protocol.subprotocol = self.protocol.process_subprotocol(headers)
+                    self.protocol.state = OPEN
+                return event
+            elif isinstance(event, Frame):
+                frame = event
+                if frame.opcode == Opcode.TEXT:
+                    message = frame.data.decode('utf-8')
+                    return message
+                elif frame.opcode == Opcode.BINARY:
+                    return frame.data
+
+                """
+                # Handle control frames, these are here for the future references.
+                elif frame.opcode == Opcode.CLOSE:
+                    close_info = Close.parse(frame.data)
+                    print(f"Connection closed by client: {close_info.code}, {close_info.reason}")
+                    # Send a close frame in response if not already sent
+                    if self.protocol.state == self.protocol.OPEN:
+                        self.protocol.send_close()
+                elif frame.opcode == Opcode.PING:
+                    # Respond to ping with pong
+                    self.protocol.send_pong(frame.data)
+                elif frame.opcode == Opcode.PONG:
+                    print("Received pong")
+                """

atomicshop/wrappers/factw/install/install_after_restart.py

@@ -1,14 +1,48 @@
 from typing import Union, Literal
 from pathlib import Path
 
-from .... import process, filesystem
+from .... import process, print_api
 from .. import config_install
 
 
+PLUGIN_LIST: list = [
+    'qemu_exec',
+    'binwalk',
+    'users_and_passwords',
+    'kernel_config',
+    'cve_lookup',
+    'crypto_hints',
+    'input_vectors',
+    'cwe_checker',
+    'linter',
+    'ip_and_uri_finder',
+    'device_tree',
+    'file_system_metadata',
+    'ipc',
+    'software_components',
+    'architecture_detection',
+    'known_vulnerabilities'
+]
+
+
+INSTALLING_STRINGS: list = ['Installing', 'plugin']
+FINISHED_INSTALLING_STRINGS: list = ['Finished installing', 'plugin']
+LOG_FINISHED_STRING: str = 'installation complete'
+
+
 def install_after_restart(
         installation_directory: str,
-        install_type: Union[None, Literal['backend', 'frontend', 'db']] = None
-):
+        install_type: Union[
+            None,
+            Literal['backend', 'frontend', 'db']] = None,
+        log_level: Union[
+            None,
+            Literal['DEBUG', 'INFO', 'WARNING', 'ERROR']] = None,
+        log_file: Union[
+            None,
+            str] = None,
+        analyze_log: bool = False
+) -> int:
     """
     This function will continue the installation the FACT_core after the restart of the computer.
 
@@ -20,7 +54,13 @@ def install_after_restart(
         --backend: Distributed setup, Install the FACT_core backend.
         --frontend: Distributed setup, Install the FACT_core frontend.
         --db: Distributed setup, Install the FACT_core database.
-    :return:
+    :param log_level: string, the log level to use for the installation.
+        The same as using the '--log-level' parameter in the 'install.py' script.
+        The default is 'INFO' in the 'install.py' script.
+    :param log_file: string, the log file to use for the installation.
+        The same as using the '--log-file' parameter in the 'install.py' script.
+    :param analyze_log: bool, if True, the log file will be analyzed for plugin installation errors.
+    :return: int, 0 if the installation was successful, otherwise 1.
     """
 
     install_command: str = 'python3 "' + str(Path(installation_directory, config_install.INSTALL_FILE_PATH)) + '"'
@@ -28,8 +68,52 @@ def install_after_restart(
     if install_type:
         install_command = install_command + ' --' + install_type
 
+    if log_level:
+        install_command = install_command + ' --log_level ' + log_level
+
+    if log_file:
+        install_command = install_command + ' --log_file "' + log_file + '"'
+
     # Install the FACT_core repo.
     process.execute_with_live_output(cmd=install_command, verbose=True)
+
+    # Analyze the log file for errors.
+    if analyze_log and (install_type == 'backend' or install_type is None):
+        if not log_file:
+            log_file = str(Path.cwd() / config_install.INSTALL_LOG_FILE_NAME)
+
+        return analyze_log_file(log_file=log_file)
+
     # Remove the FACT_core installation log.
-    working_directory_path: str = filesystem.get_working_directory()
+    # working_directory_path: str = filesystem.get_working_directory()
     # filesystem.remove_file(str(Path(working_directory_path, config_install.INSTALL_LOG_FILE_NAME)))
+
+    return 0
+
+
+def analyze_log_file(log_file: str):
+    """
+    This function will analyze the log file for plugin installation errors.
+    :param log_file:
+    :return:
+    """
+
+    with open(log_file, 'r') as file:
+        log_content: str = file.read()
+
+    for plugin in PLUGIN_LIST:
+        if f'{FINISHED_INSTALLING_STRINGS[0]} {plugin} {FINISHED_INSTALLING_STRINGS[1]}' not in log_content:
+            message = (f'Error: [{plugin}] installation failed.\n'
+                       f'Check the log file: {log_file}\n'
+                       f'Exiting...')
+            print_api.print_api(message, color='red')
+            return 1
+
+    if LOG_FINISHED_STRING not in log_content:
+        message = (f'Error: Installation failed.\n'
+                   f'Check the log file: {log_file}\n'
+                   f'Exiting...')
+        print_api.print_api(message, color='red')
+        return 1
+
+    return 0

atomicshop/wrappers/mongodbw/mongodbw.py

@@ -174,6 +174,7 @@ class MongoDBWrapper:
             self,
             collection_name: str,
             filter_query: dict = None,
+            projection: dict = None,
             page: int = None,
             items: int = None,
             sort: dict[str, Literal[
@@ -192,6 +193,7 @@ class MongoDBWrapper:
                 filter_query = None
 
             CHECK MORE EXAMPLES IN THE DOCSTRING OF THE FUNCTION 'find' BELOW which is not in this class.
+        :param projection: dict, the only fields to return or exclude.
         :param page: int, the page number (Optional).
             The results are filtered after results are fetched from db.
         :param items: int, the number of results per page (Optional).
@@ -229,7 +231,8 @@ class MongoDBWrapper:
 
         entries: list[dict] = find(
             database=self.db, collection_name=collection_name,
-            filter_query=filter_query, page=page, items=items, sort=sort,
+            filter_query=filter_query, projection=projection,
+            page=page, items=items, sort=sort,
             convert_object_id_to_str=convert_object_id_to_str, key_convert_to_dict=keys_convert_to_dict,
             mongo_client=self.client, close_client=False)
 
@@ -827,7 +830,7 @@ def find(
 
     entries: list[dict] = list(collection_items)
 
-    if convert_object_id_to_str:
+    if entries and convert_object_id_to_str and '_id' in entries[0]:
         for entry_index, entry in enumerate(entries):
             entries[entry_index]['_id'] = str(entry['_id'])
 

atomicshop/wrappers/playwrightw/javascript.py

@@ -44,8 +44,12 @@ def get_page_text_content(page) -> str:
     :return: string, text content of the page.
     """
 
-    text_content: str = page.evaluate('''() => {
-        return document.body.innerText;
-    }''')
+    # Full javascript.
+    # text_content: str = page.evaluate('''() => {
+    #     return document.body.innerText;
+    # }''')
+
+    # Short javascript.
+    text_content: str = page.evaluate("document.body.innerText")
 
     return text_content

atomicshop/wrappers/playwrightw/scenarios.py

@@ -43,8 +43,12 @@ def get_text_from_html_tag(url: str, tag_name: str, attribute: str, value: str)
 
 
 def get_page_content(
-        url: str, page_format: str = 'html', path: str = None, print_kwargs: dict = None, pdf_format: str = 'A4',
-        html_txt_convert_to_bytes: bool = True
+        url: str,
+        page_format: str = 'html',
+        path: str = None,
+        pdf_format: str = 'A4',
+        html_txt_convert_to_bytes: bool = True,
+        print_kwargs: dict = None
 ) -> any:
     """
     The function receives playwright engine and page object, navigates to URL, gets page content in specified format,
@@ -57,10 +61,10 @@ def get_page_content(
         'png' - returns png binary.
         'jpeg' - returns jpeg binary.
     :param path: string of path to save the file to. Default is None.
-    :param print_kwargs: dict, that contains all the arguments for 'print_api' function.
     :param pdf_format: string of pdf format, applicable only if 'page_format=pdf'. Default is 'A4'.
     :param html_txt_convert_to_bytes: boolean, applicable only if 'page_format=html' or 'page_format=txt'.
         Default is True.
+    :param print_kwargs: dict, that contains all the arguments for 'print_api' function.
 
     :return: any page content in specified format.
     """
@@ -95,8 +99,13 @@ def get_page_content(
 
 
 def get_page_content_in_thread(
-        url: str, page_format: str = 'html', path: str = None, print_kwargs: dict = None, pdf_format: str = 'A4',
-        html_txt_convert_to_bytes: bool = True):
+        url: str,
+        page_format: str = 'html',
+        path: str = None,
+        pdf_format: str = 'A4',
+        html_txt_convert_to_bytes: bool = True,
+        print_kwargs: dict = None
+):
     """
     The function uses 'threads.thread_wrap_var' function in order to wrap the function 'get_page_content' and
     execute it in a thread with arguments and return the result.

atomicshop/wrappers/winregw/winreg_network.py

@@ -144,8 +144,23 @@ def get_default_dns_gateway() -> tuple[bool, list[str]]:
     :return: tuple(is dynamic boolean, list of DNS server IPv4s).
     """
 
+    def get_current_interface_status(current_interface_settings: dict) -> tuple[bool, list[str]]:
+        if current_interface_settings['NameServer']:
+            result = (False, current_interface_settings['NameServer'].split(','))
+        else:
+            result = (True, current_interface_settings['DhcpNameServer'].split(','))
+
+        return result
+
+
     # Get current default IPv4 address of the interface that is being used for internet.
     default_ipv4_address: str = socket.gethostbyname(socket.gethostname())
+    # If the default IPv4 address is localhost, then it could mean that the system is not connected to the internet.
+    # Or there is no network adapter at all.
+    default_dns_gateway_list: list[str] = []
+    if default_ipv4_address == '127.0.0.1':
+        from ... import dns
+        default_dns_gateway_list = dns.get_default_dns_gateway_with_dns_resolver()
 
     # Get all network interface settings from the registry.
     all_interfaces_configurations = get_network_interfaces_settings()
@@ -153,22 +168,36 @@ def get_default_dns_gateway() -> tuple[bool, list[str]]:
     # Find the interface that has this IPv4 assigned.
     function_result: tuple = tuple()
     for interface_guid, interface_settings in all_interfaces_configurations.items():
-        current_interface_static_ipv4_address: list = interface_settings.get('IPAddress', None)
-        current_interface_dynamic_ipv4_address: str = interface_settings.get('DhcpIPAddress', None)
-
-        static_and_ip_match: bool = (
-                current_interface_static_ipv4_address and
-                current_interface_static_ipv4_address[0] == default_ipv4_address)
-        dynamic_and_ip_match: bool = (
-                current_interface_dynamic_ipv4_address and
-                current_interface_dynamic_ipv4_address == default_ipv4_address)
-        if static_and_ip_match or dynamic_and_ip_match:
-            if interface_settings['NameServer']:
-                function_result = (False, interface_settings['NameServer'].split(','))
-            else:
-                function_result = (True, interface_settings['DhcpNameServer'].split(','))
-
-            break
+        if not interface_settings:
+            continue
+
+        if ' ' in interface_settings['NameServer']:
+            interface_settings['NameServer'] = interface_settings['NameServer'].replace(' ', ',')
+        if ' ' in interface_settings['DhcpNameServer']:
+            interface_settings['DhcpNameServer'] = interface_settings['DhcpNameServer'].replace(' ', ',')
+
+        if not default_dns_gateway_list:
+            current_interface_static_ipv4_address: list = interface_settings.get('IPAddress', None)
+            current_interface_dynamic_ipv4_address: str = interface_settings.get('DhcpIPAddress', None)
+
+            static_and_ip_match: bool = (
+                    current_interface_static_ipv4_address and
+                    current_interface_static_ipv4_address[0] == default_ipv4_address)
+            dynamic_and_ip_match: bool = (
+                    current_interface_dynamic_ipv4_address and
+                    current_interface_dynamic_ipv4_address == default_ipv4_address)
+            if static_and_ip_match or dynamic_and_ip_match:
+                function_result = get_current_interface_status(interface_settings)
+
+                break
+        else:
+            current_interface_name_server_list: list[str] = interface_settings['NameServer'].split(',')
+            current_interface_dhcp_name_server_list: list[str] = interface_settings['DhcpNameServer'].split(',')
+            if (current_interface_name_server_list == default_dns_gateway_list or
+                    current_interface_dhcp_name_server_list == default_dns_gateway_list):
+                function_result = get_current_interface_status(interface_settings)
+
+                break
 
     # noinspection PyTypeChecker
     return function_result

{atomicshop-2.16.42.dist-info → atomicshop-2.16.44.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.16.42
+Version: 2.16.44
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License: MIT License
@@ -60,6 +60,7 @@ Requires-Dist: SoundCard
 Requires-Dist: soundfile
 Requires-Dist: SpeechRecognition
 Requires-Dist: tldextract
+Requires-Dist: websockets
 Requires-Dist: pywin32 ; platform_system == "Windows"
 
 <h1 align="center">Atomic Workshop</h1>

{atomicshop-2.16.42.dist-info → atomicshop-2.16.44.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=tWZJJS59JBaRpS5l3fKPYI9YQJf0dM6cQNGppw5sjoo,124
+atomicshop/__init__.py,sha256=cTkolJcyCusHq9bBDXgphXYHAv5YCLiWysUXbZegGZc,124
 atomicshop/_basics_temp.py,sha256=6cu2dd6r2dLrd1BRNcVDKTHlsHs_26Gpw8QS6v32lQ0,3699
 atomicshop/_create_pdf_demo.py,sha256=Yi-PGZuMg0RKvQmLqVeLIZYadqEZwUm-4A9JxBl_vYA,3713
 atomicshop/_patch_import.py,sha256=ENp55sKVJ0e6-4lBvZnpz9PQCt3Otbur7F6aXDlyje4,6334
@@ -10,7 +10,7 @@ atomicshop/console_output.py,sha256=AOSJjrRryE97PAGtgDL03IBtWSi02aNol8noDnW3k6M,
 atomicshop/console_user_response.py,sha256=31HIy9QGXa7f-GVR8MzJauQ79E_ZqAeagF3Ks4GGdDU,3234
 atomicshop/datetimes.py,sha256=IQZ66lmta-ZqxYbyHzm_9eugbJFSilXK1e0kfMgoXGg,18371
 atomicshop/diff_check.py,sha256=Q9RCqRa-jEgo7Fujx08_JTuZ6qcgttMI6aNYB6zN9Ik,27173
-atomicshop/dns.py,sha256=3AWZFczxwuYPyVG2r_gXrmHOyLYaqWjO7QYQk9Heghk,6484
+atomicshop/dns.py,sha256=5Gimq_WY2arqg7BeGmR7P--fGfnH0Dsh8lrOt_H0jRY,6817
 atomicshop/domains.py,sha256=Rxu6JhhMqFZRcoFs69IoEd1PtYca0lMCG6F1AomP7z4,3197
 atomicshop/emails.py,sha256=I0KyODQpIMEsNRi9YWSOL8EUPBiWyon3HRdIuSj3AEU,1410
 atomicshop/file_types.py,sha256=-0jzQMRlmU1AP9DARjk-HJm1tVE22E6ngP2mRblyEjY,763
@@ -19,7 +19,7 @@ atomicshop/functions.py,sha256=pK8hoCE9z61PtWCxQJsda7YAphrLH1wxU5x-1QJP-sY,499
 atomicshop/get_process_list.py,sha256=8cxb7gKe9sl4R6H2yMi8J6oe-RkonTvCdKjRFqi-Fs4,6075
 atomicshop/get_process_name_cmd_dll.py,sha256=CtaSp3mgxxJKCCVW8BLx6BJNx4giCklU_T7USiCEwfc,5162
 atomicshop/hashing.py,sha256=Le8qGFyt3_wX-zGTeQShz7L2HL_b6nVv9PnawjglyHo,3474
-atomicshop/http_parse.py,sha256=bIrJODFmumfI6uSwWkTtjtJWS-o40kn_eg7J9Mmwr20,10002
+atomicshop/http_parse.py,sha256=WoUoz5HeiIjPzFQYn7d2aeuAKa0kVWvrswyKMZT6VUg,10039
 atomicshop/inspect_wrapper.py,sha256=sGRVQhrJovNygHTydqJj0hxES-aB2Eg9KbIk3G31apw,11429
 atomicshop/ip_addresses.py,sha256=Hvi4TumEFoTEpKWaq5WNF-YzcRzt24IxmNgv-Mgax1s,1190
 atomicshop/keyboard_press.py,sha256=1W5kRtOB75fulVx-uF2yarBhW0_IzdI1k73AnvXstk0,452
@@ -44,7 +44,8 @@ atomicshop/timer.py,sha256=7Zw1KRV0acHCRATMnanyX2MLBb63Hc-6us3rCZ9dNlY,2345
 atomicshop/urls.py,sha256=aJ0NGS9qqaKeqjkkWBs80jaBBg6MYBiPuLIyPGxscVc,1557
 atomicshop/uuids.py,sha256=JSQdm3ZTJiwPQ1gYe6kU0TKS_7suwVrHc8JZDGYlydM,2214
 atomicshop/virtualization.py,sha256=LPP4vjE0Vr10R6DA4lqhfX_WaNdDGRAZUW0Am6VeGco,494
-atomicshop/web.py,sha256=DkpdUYiwRu_Du5J8LlUyxLj-NAEnDLfEwfVlSI22trM,11642
+atomicshop/web.py,sha256=GLdTXgMxg1_0UQaXC4bOvARVyuFg7SPIeJdsCHV8rNE,11662
+atomicshop/websocket_parse.py,sha256=PygRqEFnqEcPx3PNRtJoZcKN-mXvT_zighzTJR_B-Tc,14934
 atomicshop/a_installs/ubuntu/docker_rootless.py,sha256=9IPNtGZYjfy1_n6ZRt7gWz9KZgR6XCgevjqq02xk-o0,281
 atomicshop/a_installs/ubuntu/docker_sudo.py,sha256=JzayxeyKDtiuT4Icp2L2LyFRbx4wvpyN_bHLfZ-yX5E,281
 atomicshop/a_installs/ubuntu/elastic_search_and_kibana.py,sha256=yRB-l1zBxdiN6av-FwNkhcBlaeu4zrDPjQ0uPGgpK2I,244
@@ -84,7 +85,7 @@ atomicshop/basics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 atomicshop/basics/ansi_escape_codes.py,sha256=WtIkm-BjSZS5J5irDUdAMBNvdX-qXFZcTX98jcBMpJE,3140
 atomicshop/basics/argparse_template.py,sha256=horwgSf3MX1ZgRnYxtmmQuz9OU_vKrKggF65gmjlmfg,5836
 atomicshop/basics/booleans.py,sha256=V36NaMf8AffhCom_ovQeOZlYcdtGyIcQwWKki6h7O0M,1745
-atomicshop/basics/bytes_arrays.py,sha256=WvSRDhIGt1ywF95t-yNgpxLm1nlZUbM1Dz6QckcyE8Y,5915
+atomicshop/basics/bytes_arrays.py,sha256=tU7KF0UAFSErGNcan4Uz1GJxeIYVRuUu9sHVZHgyNnw,6542
 atomicshop/basics/classes.py,sha256=T0Bm13hKvkXG3med68ptL7XuoWiCi3TE-K5TMINDlrY,10655
 atomicshop/basics/dicts.py,sha256=DeYHIh940pMMBrFhpXt4dsigFVYzTrlqWymNo4Pq_Js,14049
 atomicshop/basics/dicts_nested.py,sha256=StYxYnYPa0SEJr1lmEwAv5zfERWWqoULeyG8e0zRAwE,4107
@@ -116,7 +117,7 @@ atomicshop/etws/traces/trace_dns.py,sha256=WvOZm7KNdP4r6ofkZhUGi9WjtYlkV3mUp_yxi
 atomicshop/etws/traces/trace_sysmon_process_creation.py,sha256=OM-bkK38uYMwWLZKNOTDa0Xdk3sO6sqsxoMUIiPvm5g,4656
 atomicshop/file_io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/file_io/csvs.py,sha256=jBdm3_z5cMyvxLxJnGcybUAptHAbyL0r0tlLqY0sdTQ,9327
-atomicshop/file_io/docxs.py,sha256=ffJhnmM_WyD8mCoq2dGdpfahdIrGTPy96QVlH5EWjeI,5754
+atomicshop/file_io/docxs.py,sha256=3ctQ9JiGx8K8EYeKWiuraLtqhilW1qk1cZX9lHv0usk,5753
 atomicshop/file_io/file_io.py,sha256=5Kl0P6vF4GQVdwew1lzHLb-db9qiMvDjTgccbi5P-zk,7167
 atomicshop/file_io/jsons.py,sha256=q9ZU8slBKnHLrtn3TnbK1qxrRpj5ZvCm6AlsFzoANjo,5303
 atomicshop/file_io/tomls.py,sha256=ol8EvQPf9sryTmZUf1v55BYSUQ6ml7HVVBHpNKbsIlA,9768
@@ -125,11 +126,11 @@ atomicshop/file_io/xmls.py,sha256=zh3SuK-dNaFq2NDNhx6ivcf4GYCfGM8M10PcEwDSpxk,21
 atomicshop/mitm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/config_static.py,sha256=ROAtbibSWSsF3BraUbhu-QO3MPIFqYY5KUKgsQbiSkk,7813
 atomicshop/mitm/config_toml_editor.py,sha256=2p1CMcktWRR_NW-SmyDwylu63ad5e0-w1QPMa8ZLDBw,1635
-atomicshop/mitm/connection_thread_worker.py,sha256=q_h4rRHupuUMwGsHEyKUhOLCtIAEHDB4loLrxApzQvQ,17859
+atomicshop/mitm/connection_thread_worker.py,sha256=DxHCgDtCbSQCIX80WK9hJhp3v37pMjmm-mr3y6tyJMY,17581
 atomicshop/mitm/import_config.py,sha256=0Ij14aISTllTOiWYJpIUMOWobQqGofD6uafui5uWllE,9272
 atomicshop/mitm/initialize_engines.py,sha256=VyJE8QnzlgD3QbX5inz5o6rC3zQ3is9CeTL7-B10g1w,8292
 atomicshop/mitm/message.py,sha256=URR5JKSuAT8XmGIkyprEjlPW2GW4ef_gfUz_GgcFseE,2184
-atomicshop/mitm/mitm_main.py,sha256=tT6U4UuJ1PgNs__gDkExSR_qIbCjdBPkOQl8RPMMC5c,23224
+atomicshop/mitm/mitm_main.py,sha256=5c-9oxBiLueTbZr4Dyd4EEOorEUix5vSWxX9p5O1fBs,23375
 atomicshop/mitm/recs_files.py,sha256=mMyO1kPB-VkS_pbWCDhZHKdbWzlPbYSout61QuzHOao,3077
 atomicshop/mitm/shared_functions.py,sha256=l6oEyv4ug5D_03V3QLADYoocbcL2Ml_dYVW2WKM21l4,1818
 atomicshop/mitm/statistic_analyzer.py,sha256=5_sAYGX2Xunzo_pS2W5WijNCwr_BlGJbbOO462y_wN4,27533
@@ -228,7 +229,7 @@ atomicshop/wrappers/factw/fact_extractor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5
 atomicshop/wrappers/factw/fact_extractor/docker_image.py,sha256=2FyYjnw8gxFNwISQ83OwH-iGivkFi6EAluyCZ0loHEQ,2501
 atomicshop/wrappers/factw/fact_extractor/get_extractor.py,sha256=2mfOAftHIlCcGt1s7MWdq7DsDCuI6wX3MtvcEZ4SK-0,756
 atomicshop/wrappers/factw/install/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/wrappers/factw/install/install_after_restart.py,sha256=-VXC3KDX2BzF0oi0ELCmfch55vLk-3t16KxlmYyUGD8,1560
+atomicshop/wrappers/factw/install/install_after_restart.py,sha256=cr8E9BAEdpJXJ1VdyXr85byU0PvE3tPV0uPALQOmiKg,4318
 atomicshop/wrappers/factw/install/pre_install_and_install_before_restart.py,sha256=GFsO9MTH0czKoxkiPJtjalilUwsmFLBCcx9Znv37S4M,5945
 atomicshop/wrappers/factw/postgresql/__init__.py,sha256=xMBn2d3Exo23IPP2F_9-SXmOlhFbwWDgS9KwozSTjA0,162
 atomicshop/wrappers/factw/postgresql/analysis.py,sha256=2Rxzy2jyq3zEKIo53z8VkjuslKE_i5mq2ZpmJAvyd6U,716
@@ -257,7 +258,7 @@ atomicshop/wrappers/mongodbw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 atomicshop/wrappers/mongodbw/install_mongodb_ubuntu.py,sha256=pmI9AwWJ2cv5h8GionSpSJkllg6kfp0M381pk6y4Y5U,4015
 atomicshop/wrappers/mongodbw/install_mongodb_win.py,sha256=3ZPqrXxj3lC-PnAKGXclylLuOqsbyXYeUpb5iGjdeUU,6626
 atomicshop/wrappers/mongodbw/mongo_infra.py,sha256=IjEF0jPzQz866MpTm7rnksnyyWQeUT_B2h2DA9ryAio,2034
-atomicshop/wrappers/mongodbw/mongodbw.py,sha256=Vxsw0lNaJxAVzQWRx_9dNQXKTIKjMyZnx9FbYbINkBk,52435
+atomicshop/wrappers/mongodbw/mongodbw.py,sha256=IkEw86QFyVRU-5p5s6_6yupvSxmaQxr59GKNgSEkAm4,52617
 atomicshop/wrappers/nodejsw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/nodejsw/install_nodejs.py,sha256=TKGa3jSlSqZTL2NA0nMkWDFtlkz7rxGGn44ywCg7MN8,5228
 atomicshop/wrappers/playwrightw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -266,11 +267,11 @@ atomicshop/wrappers/playwrightw/base.py,sha256=WeRpx8otdXuKSr-BjY-uCJTze21kbPpfi
 atomicshop/wrappers/playwrightw/combos.py,sha256=215y7wugyyBrFK9_0WutnMXsF1jqJ2PLm9eHEa2PMz0,7145
 atomicshop/wrappers/playwrightw/engine.py,sha256=fapOeaqSMNoxJucTvhzp30cKfKNSVe45drhZJcJ-fOk,15191
 atomicshop/wrappers/playwrightw/infra.py,sha256=ncp62l6CgAgLz4lqBtKEWZO_6ES8cqnbzJBov-tlpBo,97
-atomicshop/wrappers/playwrightw/javascript.py,sha256=CL3tVE9C4SVvy76FEgGCl77B-xziCG6JZR5Ed8IfcSo,1112
+atomicshop/wrappers/playwrightw/javascript.py,sha256=_bW7CAtm0Y8IHYrAalg5HpPFnk6juiqicmkvZ9dITaA,1235
 atomicshop/wrappers/playwrightw/keyboard.py,sha256=zN3YddGO-qUkn6C0CRVFejP4cTuaUwXLDNFhFREjERY,422
 atomicshop/wrappers/playwrightw/locators.py,sha256=6wsLywZxDuii7mwv-zQsRbqQC8r7j96Bma5b5_7ZoVo,2411
 atomicshop/wrappers/playwrightw/mouse.py,sha256=-2FZbQtjgH7tdXWld6ZPGqlKFUdf5in0ujN0hewxa50,656
-atomicshop/wrappers/playwrightw/scenarios.py,sha256=Wz7aVYfG7K4fuSe_TUAc1jhFXVq5jYvZKbDtvqUiONc,5236
+atomicshop/wrappers/playwrightw/scenarios.py,sha256=OzI3SV0QgazRwMZ0hMEopDHUYG-aygBSxZ50w78lIP8,5310
 atomicshop/wrappers/playwrightw/waits.py,sha256=PBFdz_PoM7Fo7O8hLqMrxNPzBEYgPoXwZceFFCGGeu8,7182
 atomicshop/wrappers/psutilw/cpus.py,sha256=w6LPBMINqS-T_X8vzdYkLS2Wzuve28Ydp_GafTCngrc,236
 atomicshop/wrappers/psutilw/disks.py,sha256=3ZSVoommKH1TWo37j_83frB-NqXF4Nf5q5mBCX8G4jE,9221
@@ -313,9 +314,9 @@ atomicshop/wrappers/socketw/socket_wrapper.py,sha256=WtylpezgIIBuz-A6PfM0hO1sm9E
 atomicshop/wrappers/socketw/ssl_base.py,sha256=kmiif84kMhBr5yjQW17p935sfjR5JKG0LxIwBA4iVvU,2275
 atomicshop/wrappers/socketw/statistics_csv.py,sha256=w1AH-zf4mBuT4euf28UKij9ihM-b1BRU9Qfby0QDdqI,2957
 atomicshop/wrappers/winregw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/wrappers/winregw/winreg_network.py,sha256=4tIBitgT4X_y76k3T1ychRu85KNRflLfjFumSmoj7es,7138
-atomicshop-2.16.42.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.16.42.dist-info/METADATA,sha256=PPS3bp3ZqUTDio5PNmC2vlny1J9gavc8P4HHXhrnaQE,10473
-atomicshop-2.16.42.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-atomicshop-2.16.42.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.16.42.dist-info/RECORD,,
+atomicshop/wrappers/winregw/winreg_network.py,sha256=ChnVG8ZecKJ-DMF8nUHRiifWJq2M4slEwKat6FBfPfE,8685
+atomicshop-2.16.44.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.16.44.dist-info/METADATA,sha256=yeA-HD5CtX5FhTCrJG9ylhYHECkHvJL_ai4gaOnilY4,10500
+atomicshop-2.16.44.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-2.16.44.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.16.44.dist-info/RECORD,,