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

atomicshop/mitm/connection_thread_worker.py

@@ -2,6 +2,8 @@ from datetime import datetime
 import threading
 import queue
 import socket
+import ssl
+from typing import Literal
 
 from ..wrappers.socketw import receiver, sender, socket_client, base
 from .. import websocket_parse, ip_addresses
@@ -187,13 +189,19 @@ def thread_worker_main(
     def create_requester_request(
             client_message: ClientMessage,
             sending_socket: socket.socket
-    ) -> list[bytes]:
+    ) -> tuple[bytes, bool]:
+        request_received_raw: bytes = client_message.request_raw_bytes
         request_custom_raw: bytes = requester.create_request(client_message, sending_socket=sending_socket)
 
-        # Output first 100 characters of the request.
-        requester.logger.info(f"{request_custom_raw[0: 100]}...")
+        if request_custom_raw is None or request_received_raw == request_custom_raw:
+            is_requester_worked: bool = False
+        else:
+            is_requester_worked: bool = True
+
+            # Output first 100 characters of the request.
+            requester.logger.info(f"{request_custom_raw[0: 100]}...")
 
-        return [request_custom_raw]
+        return request_custom_raw, is_requester_worked
 
     def create_responder_response(client_message: ClientMessage) -> list[bytes]:
         if client_message.action == 'service_connect':
@@ -335,6 +343,260 @@ def thread_worker_main(
 
         return client_message
 
+    def receive_send_service_connect(
+            client_connection_message: ClientMessage,
+            sending_socket: ssl.SSLSocket | socket.socket
+    ) -> Literal['continue', 'return'] | None:
+
+        nonlocal exception_or_close_in_receiving_thread
+
+        client_message = client_connection_message
+
+        bytes_to_send_list: list[bytes] = create_responder_response(client_message)
+        print_api(f"Got responses from connect responder, count: [{len(bytes_to_send_list)}]",
+                  logger=network_logger, logger_method='info')
+
+        # If the client message is the connection message, then we'll skip to the next iteration.
+        if not bytes_to_send_list:
+            return 'continue'
+
+        # is_socket_closed: bool = False
+        error_on_send: str = str()
+        for bytes_to_send_single in bytes_to_send_list:
+            client_message.reinitialize_dynamic_vars()
+            client_message.timestamp = datetime.now()
+            client_message.response_raw_bytes = bytes_to_send_single
+            client_message.action = 'service_responder'
+            record_and_statistics_write(client_message)
+
+            # Send the bytes back to the client socket.
+            error_on_send: str = sender.Sender(
+                ssl_socket=sending_socket, class_message=bytes_to_send_single,
+                logger=network_logger).send()
+
+            if error_on_send:
+                client_message.reinitialize_dynamic_vars()
+                client_message.errors.append(error_on_send)
+                client_message.timestamp = datetime.now()
+                client_message.action = 'client_send'
+                record_and_statistics_write(client_message)
+
+        if error_on_send:
+            exception_or_close_in_receiving_thread = True
+            finish_thread()
+            return 'return'
+
+        return None
+
+    def receive_send_client_offline(
+            client_message: ClientMessage,
+            receiving_socket: ssl.SSLSocket | socket.socket,
+            sending_socket: ssl.SSLSocket | socket.socket
+    ) -> Literal['return'] | None:
+        nonlocal exception_or_close_in_receiving_thread
+        nonlocal client_receive_count
+
+        client_receive_count += 1
+
+        network_logger.info(f"Initializing Receiver for Client cycle: {str(client_receive_count)}")
+        client_message.timestamp = datetime.now()
+
+        received_raw_data, is_socket_closed, error_message = receiver.Receiver(
+            ssl_socket=receiving_socket, logger=network_logger).receive()
+
+        process_client_raw_data(received_raw_data, error_message, client_message)
+        client_message.action = 'client_receive'
+
+        record_and_statistics_write(client_message)
+
+        # If there was an exception in the service thread, then receiving empty bytes doesn't mean that
+        # the socket was closed by the other side, it means that the service thread closed the socket.
+        if (received_raw_data == b'' or error_message) and exception_or_close_in_receiving_thread:
+            print_api("Both sockets are closed, breaking the loop", logger=network_logger,
+                      logger_method='info')
+            return 'return'
+
+        # If the socket was closed on receive, and we're in offline mode, then we'll finish the thread right away.
+        # Since nothing more can be done, like responding to service or using requester.
+        if is_socket_closed:
+            exception_or_close_in_receiving_thread = True
+            finish_thread()
+            return 'return'
+
+        # Send to requester.
+        # THERE IS ALWAYS WILL BE ONLY ONE REQUEST FROM REQUESTER, SINCE THIS IS WHAT WE GOT FROM THE CLIENT.
+        request_custom_raw, is_requester_worked = create_requester_request(client_message, sending_socket=sending_socket)
+        # We will not process the raw data if requester didn't change anything.
+        if is_requester_worked:
+            client_message.reinitialize_dynamic_vars()
+            client_message.timestamp = datetime.now()
+            client_message.request_raw_bytes = request_custom_raw
+            client_message.action = 'client_requester'
+            process_client_raw_data(request_custom_raw, error_message, client_message)
+            record_and_statistics_write(client_message)
+
+        print_api("Offline Mode, sending to responder directly.", logger=network_logger,
+                  logger_method='info')
+        bytes_to_send_list: list[bytes] = create_responder_response(client_message)
+
+        error_on_send: str = str()
+        for bytes_to_send_single in bytes_to_send_list:
+            client_message.reinitialize_dynamic_vars()
+            client_message.timestamp = datetime.now()
+            client_message.response_raw_bytes = bytes_to_send_single
+            client_message.action = 'client_responder_offline'
+            process_server_raw_data(bytes_to_send_single, '', client_message)
+            record_and_statistics_write(client_message)
+
+            error_on_send: str = sender.Sender(
+                ssl_socket=receiving_socket, class_message=bytes_to_send_single,
+                logger=network_logger).send()
+
+            if error_on_send:
+                client_message.reinitialize_dynamic_vars()
+                client_message.errors.append(error_on_send)
+                client_message.timestamp = datetime.now()
+                client_message.action = 'service_send'
+
+                record_and_statistics_write(client_message)
+
+        # If the socket was closed on message receive, then we'll break the loop only after send.
+        if is_socket_closed or error_on_send:
+            exception_or_close_in_receiving_thread = True
+            finish_thread()
+            return 'return'
+
+        return None
+
+    def receive_send_client(
+            client_message: ClientMessage,
+            receiving_socket: ssl.SSLSocket | socket.socket,
+            sending_socket: ssl.SSLSocket | socket.socket
+    ) -> Literal['return'] | None:
+
+        nonlocal exception_or_close_in_receiving_thread
+        nonlocal client_receive_count
+
+        client_receive_count += 1
+
+        network_logger.info(f"Initializing Receiver for Client cycle: {str(client_receive_count)}")
+
+        # Getting message from the client over the socket using specific class.
+        client_message.timestamp = datetime.now()
+        received_raw_data, is_socket_closed, error_message = receiver.Receiver(
+            ssl_socket=receiving_socket, logger=network_logger).receive()
+
+        process_client_raw_data(received_raw_data, error_message, client_message)
+        client_message.action = 'client_receive'
+
+        record_and_statistics_write(client_message)
+
+        # If there was an exception in the service thread, then receiving empty bytes doesn't mean that
+        # the socket was closed by the other side, it means that the service thread closed the socket.
+        if (received_raw_data == b'' or error_message) and exception_or_close_in_receiving_thread:
+            print_api("Both sockets are closed, breaking the loop", logger=network_logger,
+                      logger_method='info')
+            return 'return'
+
+        # Send to requester.
+        # THERE IS ALWAYS WILL BE ONLY ONE REQUEST FROM REQUESTER, SINCE THIS IS WHAT WE GOT FROM THE CLIENT.
+        request_custom_raw, is_requester_worked = create_requester_request(client_message, sending_socket=sending_socket)
+        # We will not process the raw data if requester didn't change anything.
+        if is_requester_worked:
+            client_message.reinitialize_dynamic_vars()
+            client_message.timestamp = datetime.now()
+            client_message.request_raw_bytes = request_custom_raw
+            client_message.action = 'client_requester'
+            process_client_raw_data(request_custom_raw, error_message, client_message)
+            record_and_statistics_write(client_message)
+
+        error_on_send: str = sender.Sender(
+            ssl_socket=sending_socket, class_message=client_message.request_raw_bytes,
+            logger=network_logger).send()
+
+        if error_on_send:
+            client_message.reinitialize_dynamic_vars()
+            client_message.errors.append(error_on_send)
+            client_message.timestamp = datetime.now()
+            client_message.action = 'service_send'
+            record_and_statistics_write(client_message)
+
+        # If the socket was closed on message receive, then we'll break the loop only after send.
+        if is_socket_closed or error_on_send:
+            exception_or_close_in_receiving_thread = True
+            finish_thread()
+            return 'return'
+
+        return None
+
+    def receive_send_service(
+            client_message: ClientMessage,
+            receiving_socket: ssl.SSLSocket | socket.socket,
+            sending_socket: ssl.SSLSocket | socket.socket
+    ) -> Literal['return'] | None:
+
+        nonlocal exception_or_close_in_receiving_thread
+        nonlocal server_receive_count
+
+        server_receive_count += 1
+
+        network_logger.info(f"Initializing Receiver for Service cycle: {str(server_receive_count)}")
+
+        # Getting message from the client over the socket using specific class.
+        client_message.timestamp = datetime.now()
+        received_raw_data, is_socket_closed, error_message = receiver.Receiver(
+            ssl_socket=receiving_socket, logger=network_logger).receive()
+
+        process_server_raw_data(received_raw_data, error_message, client_message)
+        client_message.action = 'service_receive'
+        record_and_statistics_write(client_message)
+
+        # If there was an exception in the service thread, then receiving empty bytes doesn't mean that
+        # the socket was closed by the other side, it means that the service thread closed the socket.
+        if (received_raw_data == b'' or error_message) and exception_or_close_in_receiving_thread:
+            print_api("Both sockets are closed, breaking the loop", logger=network_logger,
+                      logger_method='info')
+            return 'return'
+
+        # Now send it to requester/responder.
+        bytes_to_send_list: list[bytes] = create_responder_response(client_message)
+        print_api(f"Got responses from responder, count: [{len(bytes_to_send_list)}]",
+                  logger=network_logger, logger_method='info')
+
+        # is_socket_closed: bool = False
+        error_on_send: str = str()
+        for bytes_to_send_single in bytes_to_send_list:
+            client_message.reinitialize_dynamic_vars()
+            client_message.timestamp = datetime.now()
+            client_message.response_raw_bytes = bytes_to_send_single
+
+            # This records the requester or responder output, only if it is not the same as the original
+            # message.
+            if bytes_to_send_single != received_raw_data:
+                client_message.action = 'service_responder'
+                record_and_statistics_write(client_message)
+
+            error_on_send: str = sender.Sender(
+                ssl_socket=sending_socket, class_message=bytes_to_send_single,
+                logger=network_logger).send()
+
+            if error_on_send:
+                client_message.reinitialize_dynamic_vars()
+                client_message.errors.append(error_on_send)
+                client_message.timestamp = datetime.now()
+                client_message.action = 'client_send'
+
+                record_and_statistics_write(client_message)
+
+        # If the socket was closed on message receive, then we'll break the loop only after send.
+        if is_socket_closed or error_on_send:
+            exception_or_close_in_receiving_thread = True
+            finish_thread()
+            return 'return'
+
+        return None
+
+
     def receive_send_start(
             receiving_socket,
             sending_socket = None,
@@ -360,146 +622,25 @@ def thread_worker_main(
                 raise ValueError(f"Unknown side of the socket: {receiving_socket}")
 
             while True:
-                is_socket_closed: bool = False
-                # pass the socket connect to responder.
-                if side == 'Service' and client_connection_message:
-                    client_message = client_connection_message
-
-                    bytes_to_send_list: list[bytes] = create_responder_response(client_message)
-                    print_api(f"Got responses from connect responder, count: [{len(bytes_to_send_list)}]", logger=network_logger,
-                              logger_method='info')
+                client_message.reinitialize_dynamic_vars()
 
-                    received_raw_data = None
-                else:
-                    client_message.reinitialize_dynamic_vars()
-
-                    if side == 'Client':
-                        client_receive_count += 1
-                        current_count = client_receive_count
-                    else:
-                        server_receive_count += 1
-                        current_count = server_receive_count
-
-                    # Getting current time of message received, either from client or service.
-                    client_message.timestamp = datetime.now()
-
-                    # # No need to receive on service socket if we're in offline mode, because there is no service to connect to.
-                    # if config_static.MainConfig.offline and side == 'Service':
-                    #     print_api("Offline Mode, skipping receiving on service socket.", logger=network_logger,
-                    #               logger_method='info')
-                    # else:
-
-                    network_logger.info(
-                        f"Initializing Receiver for {side} cycle: {str(current_count)}")
-
-                    # Getting message from the client over the socket using specific class.
-                    received_raw_data, is_socket_closed, error_message = receiver.Receiver(
-                        ssl_socket=receiving_socket, logger=network_logger).receive()
-
-                    # In case of client socket, we'll process the raw data specifically for the client.
-                    if side == 'Client':
-                        process_client_raw_data(received_raw_data, error_message, client_message)
-                        client_message.action = 'client_receive'
-                    # In case of service socket, we'll process the raw data specifically for the service.
-                    else:
-                        process_server_raw_data(received_raw_data, error_message, client_message)
-                        client_message.action = 'service_receive'
-
-                    # If there was an exception in the service thread, then receiving empty bytes doesn't mean that
-                    # the socket was closed by the other side, it means that the service thread closed the socket.
-                    if (received_raw_data == b'' or error_message) and exception_or_close_in_receiving_thread:
-                        print_api("Both sockets are closed, breaking the loop", logger=network_logger,
-                                  logger_method='info')
-                        return
-
-                    # We will record only if there was no closing signal, because if there was, it means that we initiated
-                    # the close on the opposite socket.
-                    record_and_statistics_write(client_message)
-
-                    # if is_socket_closed:
-                    #     exception_or_close_in_receiving_thread = True
-                    #     finish_thread()
-                    #     return
-
-                    # Now send it to requester/responder.
-                    if side == 'Client':
-                        # Send to requester.
-                        bytes_to_send_list: list[bytes] = create_requester_request(
-                            client_message, sending_socket=sending_socket)
-
-                        # If we're in offline mode, then we'll put the request to the responder right away.
-                        if config_static.MainConfig.offline:
-                            print_api("Offline Mode, sending to responder directly.", logger=network_logger,
-                                      logger_method='info')
-                            process_client_raw_data(bytes_to_send_list[0], error_message, client_message)
-                            bytes_to_send_list = create_responder_response(client_message)
-                    elif side == 'Service':
-                        bytes_to_send_list: list[bytes] = create_responder_response(client_message)
-                        print_api(f"Got responses from responder, count: [{len(bytes_to_send_list)}]",
-                                  logger=network_logger,
-                                  logger_method='info')
-                    else:
-                        raise ValueError(f"Unknown side [{side}] of the socket: {receiving_socket}")
-
-
-                # If nothing was passed from the responder, and the client message is the connection message, then we'll skip to the next iteration.
-                if not bytes_to_send_list and client_connection_message:
+                if side == 'Service' and client_connection_message:
+                    result: Literal['continue', 'return'] | None = (
+                        receive_send_service_connect(client_connection_message, sending_socket))
                     client_connection_message = None
-                    continue
-
-                # is_socket_closed: bool = False
-                error_on_send: str = str()
-                for bytes_to_send_single in bytes_to_send_list:
-                    client_message.reinitialize_dynamic_vars()
-                    client_message.timestamp = datetime.now()
-
-                    if side == 'Client':
-                        client_message.request_raw_bytes = bytes_to_send_single
-                    else:
-                        client_message.response_raw_bytes = bytes_to_send_single
-
-                    # This records the requester or responder output, only if it is not the same as the original
-                    # message.
-                    if bytes_to_send_single != received_raw_data:
-                        if side == 'Client':
-                            client_message.action = 'client_requester'
-
-                            if config_static.MainConfig.offline:
-                                client_message.action = 'client_responder_offline'
-                        elif side == 'Service':
-                            client_message.action = 'service_responder'
-                        record_and_statistics_write(client_message)
-
-                    # If we're in offline mode, it means we're in the client thread, and we'll send the
-                    # bytes back to the client socket.
-                    if config_static.MainConfig.offline:
-                        error_on_send: str = sender.Sender(
-                            ssl_socket=receiving_socket, class_message=bytes_to_send_single,
-                            logger=network_logger).send()
-                    else:
-                        error_on_send: str = sender.Sender(
-                            ssl_socket=sending_socket, class_message=bytes_to_send_single,
-                            logger=network_logger).send()
-
-                    if error_on_send:
-                        client_message.reinitialize_dynamic_vars()
-                        client_message.errors.append(error_on_send)
-                        client_message.timestamp = datetime.now()
-                        if side == 'Client':
-                            client_message.action = 'service_send'
-                        else:
-                            client_message.action = 'client_send'
-
-                        record_and_statistics_write(client_message)
-
-                # If the socket was closed on message receive, then we'll break the loop only after send.
-                if is_socket_closed or error_on_send:
-                    exception_or_close_in_receiving_thread = True
-                    finish_thread()
-                    return
+                    if result == 'continue':
+                        continue
+                elif side == 'Client' and config_static.MainConfig.offline:
+                    result: Literal['return'] | None = receive_send_client_offline(client_message, receiving_socket, sending_socket)
+                elif side == 'Client':
+                    result: Literal['return'] | None = receive_send_client(client_message, receiving_socket, sending_socket)
+                elif side == 'Service':
+                    result: Literal['return'] | None = receive_send_service(client_message, receiving_socket, sending_socket)
+                else:
+                    raise ValueError(f"Unknown side [{side}] of the socket: {receiving_socket}")
 
-                # For next iteration to start in case this iteration was responsible to process connection message, we need to set it to None.
-                client_connection_message = None
+                if result == 'return':
+                    return
         except Exception as exc:
             # If the sockets were already closed, then there is nothing to do here besides log.
             # if (isinstance(exc, OSError) and exc.errno == 10038 and
@@ -602,7 +743,13 @@ def thread_worker_main(
     try:
         engine_name: str = recorder.engine_name
         client_ip, source_port = client_socket.getpeername()
-        client_name: str = socket.gethostbyaddr(client_ip)[0]
+
+        try:
+            client_name: str = socket.gethostbyaddr(client_ip)[0]
+        # This can happen if the host changed IP address, but it wasn't propagated over DHCP.
+        except socket.herror:
+            client_name = ""
+
         client_name = client_name.lower()
         destination_port: int = client_socket.getsockname()[1]
         destination_port_str: str = str(destination_port)

atomicshop/mitm/engines/__parent/requester___parent.py

@@ -112,5 +112,5 @@ class RequesterParent:
     def create_request(self, class_client_message: ClientMessage, **kwargs) -> bytes:
         """ This function should be overridden in the child class. """
 
-        request_bytes: bytes = class_client_message.request_raw_bytes
+        request_bytes: bytes = None
         return request_bytes

atomicshop/wrappers/githubw.py

@@ -163,11 +163,103 @@ class GitHubWrapper:
 
         self.build_links_from_user_and_repo()
 
-    def check_github_domain(self, domain):
+    def check_github_domain(
+            self,
+            domain: str
+    ):
         if self.domain not in domain:
             print_api(
                 f'This is not [{self.domain}] domain.', color="red", error_type=True)
 
+    def download_file(
+            self,
+            file_name: str,
+            target_dir: str
+    ) -> str:
+        """
+        Download a single repo file to a local directory.
+
+        :param file_name: string, Full repo-relative path to the file. Example:
+             "eng.traineddata"
+             "script\\English.script"
+        :param target_dir: string, Local directory to save into.
+
+        :return: The local path to the downloaded file.
+        """
+
+        # Normalize to GitHub path format
+        file_path = file_name.replace("\\", "/").strip("/")
+
+        headers = self._get_headers()
+        url = f"{self.contents_url}/{file_path}"
+        params = {"ref": self.branch}
+
+        resp = requests.get(url, headers=headers, params=params)
+        resp.raise_for_status()
+        item = resp.json()
+
+        # Expect a single file object
+        if isinstance(item, list) or item.get("type") != "file":
+            raise ValueError(f"'{file_name}' is not a file in branch '{self.branch}'.")
+
+        download_url = item.get("download_url")
+        if not download_url:
+            raise ValueError(f"Unable to obtain download URL for '{file_name}'.")
+
+        os.makedirs(target_dir, exist_ok=True)
+        local_name = item.get("name") or os.path.basename(file_path)
+
+        from .. import web  # ensure available in your module structure
+        web.download(
+            file_url=download_url,
+            target_directory=target_dir,
+            file_name=local_name,
+            headers=headers,
+        )
+        return os.path.join(target_dir, local_name)
+
+    def download_directory(
+            self,
+            folder_name: str,
+            target_dir: str
+    ) -> None:
+        """
+        Recursively download a repo directory to a local directory.
+
+        :param folder_name: string, Repo-relative directory path to download (e.g., "tests/langs").
+        :param target_dir: string, Local directory to save the folder tree into.
+        """
+        headers = self._get_headers()
+        root_path = folder_name.replace("\\", "/").strip("/")
+
+        def _walk_dir(rel_path: str, local_dir: str) -> None:
+            contents_url = f"{self.contents_url}/{rel_path}" if rel_path else self.contents_url
+            params = {"ref": self.branch}
+
+            response = requests.get(contents_url, headers=headers, params=params)
+            response.raise_for_status()
+            items = response.json()
+
+            # If a file path was passed accidentally, delegate to download_file
+            if isinstance(items, dict) and items.get("type") == "file":
+                self.download_file(rel_path, local_dir)
+                return
+
+            if not isinstance(items, list):
+                raise ValueError(f"Unexpected response shape when listing '{rel_path or '/'}'.")
+
+            os.makedirs(local_dir, exist_ok=True)
+
+            for item in items:
+                name = item["name"]
+                if item["type"] == "file":
+                    self.download_file(f"{rel_path}/{name}" if rel_path else name, local_dir)
+                elif item["type"] == "dir":
+                    _walk_dir(f"{rel_path}/{name}" if rel_path else name, os.path.join(local_dir, name))
+                # ignore symlinks/submodules if present
+
+        _walk_dir(root_path, target_dir)
+
     def download_and_extract_branch(
             self,
             target_directory: str,
@@ -195,48 +287,6 @@ class GitHubWrapper:
         :return:
         """
 
-        def download_file(file_url: str, target_dir: str, file_name: str, current_headers: dict) -> None:
-            os.makedirs(target_dir, exist_ok=True)
-
-            web.download(
-                file_url=file_url,
-                target_directory=target_dir,
-                file_name=file_name,
-                headers=current_headers
-            )
-
-        def download_directory(folder_path: str, target_dir: str, current_headers: dict) -> None:
-            # Construct the API URL for the current folder.
-            contents_url = f"{self.contents_url}/{folder_path}"
-            params = {'ref': self.branch}
-
-            response = requests.get(contents_url, headers=current_headers, params=params)
-            response.raise_for_status()
-
-            # Get the list of items (files and subdirectories) in the folder.
-            items = response.json()
-
-            # Ensure the local target directory exists.
-            os.makedirs(target_dir, exist_ok=True)
-
-            # Process each item.
-            for item in items:
-                local_item_path = os.path.join(target_dir, item['name'])
-                if item['type'] == 'file':
-                    download_file(
-                        file_url=item['download_url'],
-                        target_dir=target_dir,
-                        file_name=item['name'],
-                        current_headers=current_headers
-                    )
-                elif item['type'] == 'dir':
-                    # Recursively download subdirectories.
-                    download_directory(
-                        folder_path=f"{folder_path}/{item['name']}",
-                        target_dir=local_item_path,
-                        current_headers=current_headers
-                    )
-
         headers: dict = self._get_headers()
 
         if not download_each_file:
@@ -275,7 +325,7 @@ class GitHubWrapper:
             else:
                 current_target_directory = os.path.join(target_directory, self.path)
 
-            download_directory(self.path, current_target_directory, headers)
+            self.download_directory(self.path, current_target_directory)
 
     def get_releases_json(
             self,
@@ -530,8 +580,77 @@ class GitHubWrapper:
         commit_message = latest_commit.get("commit", {}).get("message", "")
         return commit_message
 
+    def list_files(
+            self,
+            pattern: str = "*",
+            recursive: bool = True,
+            path: str | None = None,
+    ) -> list[str]:
+        """
+        List files in the repository (or in a specific subfolder).
 
-def parse_github_args():
+        :param pattern: Glob-style pattern (e.g., "*.ex*", "*test*.py"). Matching is done
+            against the file's base name (not the full path).
+        :param recursive: If True, include files in all subfolders (returns full repo-relative
+            paths). If False, list only the immediate files in the chosen folder.
+        :param path: Optional subfolder to list from (e.g., "tests/langs"). If omitted,
+            uses self.path if set, otherwise the repo root.
+
+        :return: A list of repo-relative file paths that match the pattern.
+        """
+        headers = self._get_headers()
+        base_path = (path or self.path or "").strip("/")
+
+        if recursive:
+            # Use the Git Trees API to fetch all files in one call, then filter.
+            tree_url = f"{self.api_url}/git/trees/{self.branch}"
+            params = {"recursive": "1"}
+            resp = requests.get(tree_url, headers=headers, params=params)
+            resp.raise_for_status()
+            data = resp.json()
+
+            files = []
+            for entry in data.get("tree", []):
+                if entry.get("type") != "blob":
+                    continue  # only files
+                entry_path = entry.get("path", "")
+                # If a base_path was provided, keep only files under it
+                if base_path and not entry_path.startswith(base_path + "/") and entry_path != base_path:
+                    continue
+                # Match pattern against the *file name* (basename)
+                if fnmatch.fnmatch(os.path.basename(entry_path), pattern):
+                    files.append(entry_path)
+            return files
+
+        else:
+            # Non-recursive: use the Contents API to list a single directory.
+            # If base_path is empty, list the repo root.
+            if base_path:
+                contents_url = f"{self.contents_url}/{base_path}"
+            else:
+                contents_url = self.contents_url
+
+            params = {"ref": self.branch}
+            resp = requests.get(contents_url, headers=headers, params=params)
+            resp.raise_for_status()
+            items = resp.json()
+
+            # The Contents API returns a dict when the path points to a single file;
+            # normalize to a list to simplify handling.
+            if isinstance(items, dict):
+                items = [items]
+
+            files = []
+            for item in items:
+                if item.get("type") == "file":
+                    name = item.get("name", "")
+                    if fnmatch.fnmatch(name, pattern):
+                        # item["path"] is the full repo-relative path we want to return
+                        files.append(item.get("path", name))
+            return files
+
+
+def _make_parser():
     import argparse
 
     parser = argparse.ArgumentParser(description='GitHub Wrapper')
@@ -562,7 +681,7 @@ def parse_github_args():
         '-db', '--download_branch', action='store_true', default=False,
         help='Sets if the branch will be downloaded. In conjunction with path, only the path will be downloaded.')
 
-    return parser.parse_args()
+    return parser
 
 
 def github_wrapper_main(
@@ -571,8 +690,8 @@ def github_wrapper_main(
         path: str = None,
         target_directory: str = None,
         pat: str = None,
-        get_latest_commit_json: bool = False,
         get_latest_commit_message: bool = False,
+        get_latest_commit_json: bool = False,
         download_branch: bool = False
 ):
     """
@@ -610,15 +729,7 @@ def github_wrapper_main(
 
 
 def github_wrapper_main_with_args():
-    args = parse_github_args()
-
-    return github_wrapper_main(
-        repo_url=args.repo_url,
-        branch=args.branch,
-        path=args.path,
-        target_directory=args.target_directory,
-        pat=args.pat,
-        get_latest_commit_json=args.get_latest_commit_json,
-        get_latest_commit_message=args.get_latest_commit_message,
-        download_branch=args.download_branch
-    )
+    main_parser = _make_parser()
+    args = main_parser.parse_args()
+
+    return github_wrapper_main(**vars(args))

atomicshop/wrappers/socketw/dns_server.py

@@ -478,7 +478,7 @@ class DnsServer:
                     dns_cached_request = False
                     # Check if the received data request from client is already in the cache
                     if client_data in self.dns_questions_to_answers_cache:
-                        # message = "!!! Question / Answer is already in the dictionary..."
+                        # message = "!!! Request / Response is already in the dictionary..."
                         # self.logger.info(message)
 
                         # Get the response from the cached answers list
@@ -561,7 +561,7 @@ class DnsServer:
                                                 f'{self.offline_route_ipv6}')
                                         )
 
-                                        message = f"!!! Question / Answer is in offline mode returning " \
+                                        message = f"!!! Request / Response is in offline mode returning " \
                                                   f"{self.offline_route_ipv6}."
                                         self.logger.info(message)
 
@@ -577,7 +577,7 @@ class DnsServer:
                                     elif qtype_string == "SRV" or qtype_string == "SOA" or qtype_string == "HTTPS":
                                         dns_built_response.add_answer(*RR.fromZone(self.offline_srv_answer))
 
-                                        message = f"!!! Question / Answer is in offline mode returning: " \
+                                        message = f"!!! Request / Response is in offline mode returning: " \
                                                   f"{self.offline_srv_answer}."
                                         self.logger.info(message)
                                     elif qtype_string == "ANY":
@@ -586,7 +586,7 @@ class DnsServer:
                                                          self.offline_route_domain)
                                         )
 
-                                        message = f"!!! Question / Answer is in offline mode returning " \
+                                        message = f"!!! Request / Response is in offline mode returning " \
                                                   f"{self.offline_route_domain}."
                                         self.logger.info(message)
                                     else:
@@ -596,7 +596,7 @@ class DnsServer:
                                                 " " + self.offline_route_ipv4)
                                         )
 
-                                        message = f"!!! Question / Answer is in offline mode returning " \
+                                        message = f"!!! Request / Response is in offline mode returning " \
                                                   f"{self.offline_route_ipv4}."
                                         self.logger.info(message)
                                 # Values error means in most cases that you create wrong response

atomicshop/wrappers/socketw/sender.py

@@ -1,3 +1,4 @@
+import socket
 import ssl
 import logging
 from pathlib import Path
@@ -12,12 +13,12 @@ from . import base
 class Sender:
     def __init__(
             self,
-            ssl_socket: ssl.SSLSocket,
+            ssl_socket: ssl.SSLSocket | socket.socket,
             class_message: bytes,
             logger: logging.Logger = None
     ):
         self.class_message: bytes = class_message
-        self.ssl_socket: ssl.SSLSocket = ssl_socket
+        self.ssl_socket: ssl.SSLSocket | socket.socket = ssl_socket
 
         if logger:
             # Create child logger for the provided logger with the module's name.

{atomicshop-3.3.29.dist-info → atomicshop-3.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomicshop
-Version: 3.3.29
+Version: 3.4.0
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License-Expression: MIT

{atomicshop-3.3.29.dist-info → atomicshop-3.4.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=g-G7s5YKUYY2IiQIVuIj3eClhzuHJN9m-26BeB666_4,123
+atomicshop/__init__.py,sha256=ixOmnAbr1hvPV-ANWmylWbdUrobDsVq3iPHZfp7dYM4,122
 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
@@ -126,7 +126,7 @@ atomicshop/file_io/xmls.py,sha256=zh3SuK-dNaFq2NDNhx6ivcf4GYCfGM8M10PcEwDSpxk,21
 atomicshop/mitm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/config_static.py,sha256=KzO8DjZjRHfkQMYSIGTkW4jLNPzMR8visTqs1H6ZQ-U,8926
 atomicshop/mitm/config_toml_editor.py,sha256=2p1CMcktWRR_NW-SmyDwylu63ad5e0-w1QPMa8ZLDBw,1635
-atomicshop/mitm/connection_thread_worker.py,sha256=zPgDoIrZw6iIfjt_vwAYBanjOz23DMUZaWsBtHPUm34,33298
+atomicshop/mitm/connection_thread_worker.py,sha256=NPHizpPJOaYjP05EEGxEOOKHhgbe4CSzUuk7WTPgZd4,38858
 atomicshop/mitm/import_config.py,sha256=7aLfKqflc3ZnzKc2_Y4T0eenzQpKG94M0r-PaVwF99M,18881
 atomicshop/mitm/initialize_engines.py,sha256=qzz5jzh_lKC03bI1w5ebngVXo1K-RV3poAyW-nObyqo,11042
 atomicshop/mitm/message.py,sha256=CDhhm4BTuZE7oNZCjvIZ4BuPOW4MuIzQLOg91hJaxDI,3065
@@ -140,7 +140,7 @@ atomicshop/mitm/engines/create_module_template_main_example.py,sha256=LeQ44Rp2Gi
 atomicshop/mitm/engines/__parent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/engines/__parent/parser___parent.py,sha256=HHaCXhScl3OlPjz6eUxsDpJaZyk6BNuDMc9xCkeo2Ws,661
 atomicshop/mitm/engines/__parent/recorder___parent.py,sha256=D99cbpMneY9STSAPETa6eIxyfs_Q9etRYxm2dosA-DI,6203
-atomicshop/mitm/engines/__parent/requester___parent.py,sha256=j3QYOfQFEPSzIEWihkssNcfaLWC8cpdpi-ciPgjKNBc,5126
+atomicshop/mitm/engines/__parent/requester___parent.py,sha256=-S817ERzs1pdY2rXiQBnG4eB4sm2jsy2wycpvuiDlpI,5092
 atomicshop/mitm/engines/__parent/responder___parent.py,sha256=mtiS_6ej9nxT9UhAQR4ftMqnqL-j_kO3u8KEaoEaI9k,9495
 atomicshop/mitm/engines/__reference_general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/engines/__reference_general/parser___reference_general.py,sha256=57MEPZMAjTO6xBDZ-yt6lgGJyqRrP0Do5Gk_cgCiPns,2998
@@ -187,7 +187,7 @@ atomicshop/wrappers/astw.py,sha256=VkYfkfyc_PJLIOxByT6L7B8uUmKY6-I8XGZl4t_z828,4
 atomicshop/wrappers/configparserw.py,sha256=JwDTPjZoSrv44YKwIRcjyUnpN-FjgXVfMqMK_tJuSgU,22800
 atomicshop/wrappers/cryptographyw.py,sha256=QEUpDn8vUvMg3ADz6-4oC2kbDNC_woDlw7C0zU7qFVM,14233
 atomicshop/wrappers/ffmpegw.py,sha256=wcq0ZnAe0yajBOuTKZCCaKI7CDBjkq7FAgdW5IsKcVE,6031
-atomicshop/wrappers/githubw.py,sha256=BEEJuWd1eBfiv1FSgb76D4nEBRpFU9j37lztn-KbYa4,27548
+atomicshop/wrappers/githubw.py,sha256=95RAbxomp4GA9-7B1pk6q3aYOmrCO0vkHyhSPgr3n3Q,31924
 atomicshop/wrappers/netshw.py,sha256=8WE_576XiiHykwFuE-VkCx5CydMpFlztX4frlEteCtI,6350
 atomicshop/wrappers/numpyw.py,sha256=sBV4gSKyr23kXTalqAb1oqttzE_2XxBooCui66jbAqc,1025
 atomicshop/wrappers/olefilew.py,sha256=biD5m58rogifCYmYhJBrAFb9O_Bn_spLek_9HofLeYE,2051
@@ -300,11 +300,11 @@ atomicshop/wrappers/socketw/accepter.py,sha256=4I9ORugRDvwaqSzm_gWSjZnRwQGY8hDTl
 atomicshop/wrappers/socketw/base.py,sha256=EcosGkD8VzgBY3GeIHDSG29ThQfXwg3-GQPmBTAqTdw,3048
 atomicshop/wrappers/socketw/certificator.py,sha256=mtWPJ_ew3OSwt0-1W4jaoco1VIY4NRCrMv3mDUxb_Cc,12418
 atomicshop/wrappers/socketw/creator.py,sha256=hHq8frKQtqZ1-Xfdm2kAsxqtsLFxXKDNwgGKdVKV6yg,16192
-atomicshop/wrappers/socketw/dns_server.py,sha256=GOYMvHvS6Fx7s-DRygGqO7_o8_Qt9on3HmKxgOSznRE,55956
+atomicshop/wrappers/socketw/dns_server.py,sha256=UHq1a3NVdOrclEOOQIe-wNtIgbF8DFeNXsobvtoM1U8,55961
 atomicshop/wrappers/socketw/exception_wrapper.py,sha256=_p98OdOaKYSMqJ23pHLXBUA7NkbVmpgqcSJAdWr6wwc,7560
 atomicshop/wrappers/socketw/get_process.py,sha256=aJC-_qFUv3NgWCSUzDI72E4z8_-VTZE9NVZ0CwUoNlM,5698
 atomicshop/wrappers/socketw/receiver.py,sha256=9B3MvcDqr4C3x2fsnjG5SQognd1wRqsBgikxZa0wXG8,8243
-atomicshop/wrappers/socketw/sender.py,sha256=aX_K8l_rHjd5AWb8bi5mt8-YTkMYVRDB6DnPqK_XDUE,4754
+atomicshop/wrappers/socketw/sender.py,sha256=5ecHUlz4Sxt4oWevBFfy33jQLRXmmVLOF34njfvSbxY,4801
 atomicshop/wrappers/socketw/sni.py,sha256=uj6KKYKmSrzXcKBhVLaHQhYn1wNfIUpdnmcvn21V9iE,18176
 atomicshop/wrappers/socketw/socket_client.py,sha256=WWIiCxUX9irN9aWzJ6-1xrXNB_iv_diq3ha1yrWsNGU,22671
 atomicshop/wrappers/socketw/socket_server_tester.py,sha256=Qobmh4XV8ZxLUaw-eW4ESKAbeSLecCKn2OWFzMhadk0,6420
@@ -314,8 +314,8 @@ atomicshop/wrappers/socketw/statistics_csv.py,sha256=_gA8bMX6Sw_UCXKi2y9wNAwlqif
 atomicshop/wrappers/winregw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/winregw/winreg_installed_software.py,sha256=Qzmyktvob1qp6Tjk2DjLfAqr_yXV0sgWzdMW_9kwNjY,2345
 atomicshop/wrappers/winregw/winreg_network.py,sha256=ih0BVNwByLvf9F_Lac4EdmDYYJA3PzMvmG0PieDZrsE,9905
-atomicshop-3.3.29.dist-info/licenses/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-3.3.29.dist-info/METADATA,sha256=YW-NNKdGGuhqL6_KPk_ghosjrrYz0cj38rYlWINOAGI,9318
-atomicshop-3.3.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-atomicshop-3.3.29.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-3.3.29.dist-info/RECORD,,
+atomicshop-3.4.0.dist-info/licenses/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-3.4.0.dist-info/METADATA,sha256=7L3q8e0dAu6OukGb_M71h6kx-aLtHEr7E710wUkSUpI,9317
+atomicshop-3.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+atomicshop-3.4.0.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-3.4.0.dist-info/RECORD,,