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

atomicshop/archiver/zips.py

@@ -4,8 +4,7 @@ import zipfile
 from io import BytesIO
 from typing import Union, Literal
 
-from .. import filesystem
-from ..print_api import print_api
+from .. import filesystem, print_api
 
 
 def is_zip_zipfile(file_object: Union[str, bytes]) -> bool:
@@ -42,7 +41,7 @@ def is_zip_magic_number(file_path: str) -> bool:
         Each file within the ZIP archive starts with this signature.
     50 4B 05 06: This is the end of central directory record signature.
         It's found at the end of a ZIP file and is essential for identifying the structure of the ZIP archive,
-        especially in cases where the file is split or is a multi-part archive.
+        especially in cases where the file is split or is a multipart archive.
     50 4B 07 08: This signature is used for spanned ZIP archives (also known as split or multi-volume ZIP archives).
         It's found in the end of central directory locator for ZIP files that are split across multiple volumes.
     """
@@ -93,7 +92,7 @@ def extract_archive_with_zipfile(
                 filesystem.get_file_directory(archive_path) + os.sep +
                 filesystem.get_file_name_without_extension(archive_path))
 
-    print_api(f'Extracting to directory: {extract_directory}', **print_kwargs)
+    print_api.print_api(f'Extracting to directory: {extract_directory}', **print_kwargs)
 
     # initiating the archived file path as 'zipfile.ZipFile' object.
     with zipfile.ZipFile(archive_path) as zip_object:
@@ -113,7 +112,7 @@ def extract_archive_with_zipfile(
                 # Cut the first directory from the filename.
                 zip_info.filename = zip_info.filename.split('/', maxsplit=1)[1]
 
-            print_api(f'Extracting: {zip_info.filename}', **print_kwargs)
+            print_api.print_api(f'Extracting: {zip_info.filename}', **print_kwargs)
 
             # Extract current file from the archive using 'zip_info' of the current file with 'filename' that we
             # updated under specified parameters to specified directory.
@@ -126,7 +125,7 @@ def extract_archive_with_zipfile(
             date_time = time.mktime(zip_info.date_time + (0, 0, -1))
             # Using 'os' library, changed the datetime of the file to the object created in previous step.
             os.utime(extracted_file_path, (date_time, date_time))
-    print_api('Extraction done.', color="green", **print_kwargs)
+    print_api.print_api('Extraction done.', color="green", **print_kwargs)
 
     return extract_directory
 

atomicshop/basics/strings.py

@@ -4,7 +4,7 @@ from pathlib import Path
 import argparse
 
 from . import lists
-from ..print_api import print_api
+from .. import print_api
 
 
 def get_nth_character_from_start(input_string: str, nth: int):
@@ -537,7 +537,7 @@ def replace_string_in_file(
             file.writelines(lines)
 
     # Output the relevant line numbers
-    print_api(f"Target string found on the following lines: {changed_lines}", **(print_kwargs or {}))
+    print_api.print_api(f"Target string found on the following lines: {changed_lines}", **(print_kwargs or {}))
     return changed_lines
 
 

atomicshop/dns.py

@@ -1,8 +1,9 @@
 import argparse
 
+# noinspection PyPackageRequirements
 import dns.resolver
 
-from .print_api import print_api
+from . import print_api
 from .permissions import permissions
 from .wrappers.pywin32w.wmis import win32networkadapter
 from .wrappers.winregw import winreg_network
@@ -57,10 +58,10 @@ def resolve_dns_localhost(domain_name: str, dns_servers_list: list = None, print
         # Get only the first entry of the list of IPs [0]
         connection_ip = function_server_address[0].to_text()
         message = f"Resolved to [{connection_ip}]"
-        print_api(message, **print_kwargs)
+        print_api.print_api(message, **print_kwargs)
     except dns.resolver.NXDOMAIN:
         message = f"Domain {domain_name} doesn't exist - Couldn't resolve with {dns_servers_list}."
-        print_api(message, **print_kwargs, error_type=True, logger_method='error')
+        print_api.print_api(message, **print_kwargs, error_type=True, logger_method='error')
         pass
 
     return connection_ip
@@ -137,12 +138,13 @@ def default_dns_gateway_main() -> int:
     args = argparse_obj.parse_args()
 
     if (args.set or args.dynamic) and not (args.connection_name or args.connection_default):
-        print_api("Please provide the connection name [-cn] or use the default connection [-cd].", color='red')
+        print_api.print_api(
+            "Please provide the connection name [-cn] or use the default connection [-cd].", color='red')
         return 1
 
     if args.set or args.dynamic:
         if not permissions.is_admin():
-            print_api("You need to run this script as an administrator", color='red')
+            print_api.print_api("You need to run this script as an administrator", color='red')
             return 1
 
     if args.get:
@@ -152,7 +154,7 @@ def default_dns_gateway_main() -> int:
             is_dynamic_string = 'Dynamic'
         else:
             is_dynamic_string = 'Static'
-        print_api(f'DNS Gateway: {is_dynamic_string} - {dns_servers}', color='blue')
+        print_api.print_api(f'DNS Gateway: {is_dynamic_string} - {dns_servers}', color='blue')
     elif args.set:
         # dns_servers_list: list = args.dns_servers.split(',')
         set_connection_dns_gateway_static(

atomicshop/file_io/file_io.py

@@ -1,7 +1,7 @@
 from typing import Union
 import functools
 
-from ..print_api import print_api
+from .. import print_api
 from ..inspect_wrapper import get_target_function_default_args_and_combine_with_current
 
 
@@ -19,7 +19,7 @@ def write_file_decorator(function_name):
         # args, kwargs = put_args_to_kwargs(function_name, *args, **kwargs)
         args, kwargs = get_target_function_default_args_and_combine_with_current(function_name, *args, **kwargs)
 
-        print_api(message=f"Writing file: {kwargs['file_path']}", **kwargs)
+        print_api.print_api(message=f"Writing file: {kwargs['file_path']}", **kwargs)
 
         enable_long_file_path = kwargs.get('enable_long_file_path', False)
         if enable_long_file_path:
@@ -41,7 +41,7 @@ def write_file_decorator(function_name):
         except FileExistsError:
             message = f"Can't write file: {kwargs['file_path']}\n" \
                       f"File exists, you should enable force/overwrite mode."
-            print_api(message, error_type=True, logger_method='critical', **kwargs)
+            print_api.print_api(message, error_type=True, logger_method='critical', **kwargs)
 
     return wrapper_write_file_decorator
 
@@ -56,7 +56,7 @@ def read_file_decorator(function_name):
         continue_loop: bool = True
         while continue_loop:
             try:
-                print_api(message=f"Reading file: {kwargs['file_path']}", **kwargs)
+                print_api.print_api(message=f"Reading file: {kwargs['file_path']}", **kwargs)
                 with open(kwargs['file_path'], kwargs['file_mode'], encoding=kwargs['encoding']) as input_file:
                     # Pass the 'output_file' object to kwargs that will pass the object to the executing function.
                     kwargs['file_object'] = input_file
@@ -64,19 +64,19 @@ def read_file_decorator(function_name):
                     return function_name(**kwargs)
             except FileNotFoundError:
                 message = f"File doesn't exist: {kwargs['file_path']}"
-                print_api(message, error_type=True, logger_method='critical', **kwargs)
+                print_api.print_api(message, error_type=True, logger_method='critical', **kwargs)
                 raise
             except UnicodeDecodeError as exception_object:
                 if kwargs["encoding"] != 'utf-8':
                     message = f'File decode error, current encoding: {kwargs["encoding"]}. Will try "utf-8".'
-                    print_api(message, logger_method='error', **kwargs)
+                    print_api.print_api(message, logger_method='error', **kwargs)
                     kwargs["encoding"] = 'utf-8'
                     pass
                     continue
                 else:
                     message = f'File decode error.\n' \
                               f'{exception_object}'
-                    print_api(message, merror_type=True, logger_method='critical', **kwargs)
+                    print_api.print_api(message, merror_type=True, logger_method='critical', **kwargs)
                     continue_loop = False
 
     return wrapper_read_file_decorator

atomicshop/filesystem.py

@@ -12,10 +12,9 @@ import tempfile
 # noinspection PyPackageRequirements
 import psutil
 
-from .print_api import print_api, print_status_of_list
 from .basics import strings, list_of_dicts, list_of_classes
 from .file_io import file_io
-from . import hashing, datetimes
+from . import hashing, datetimes, print_api
 
 
 WINDOWS_DIRECTORY_SPECIAL_CHARACTERS = ['<', '>', ':', '"', '/', '\\', '|', '?', '*']
@@ -280,12 +279,12 @@ def remove_file(file_path: str, **kwargs) -> bool:
 
     try:
         os.remove(file_path)
-        print_api(f'File Removed: {file_path}')
+        print_api.print_api(f'File Removed: {file_path}')
         return True
     # Since the file doesn't exist, we actually don't care, since we want to remove it anyway.
     except FileNotFoundError:
         message = f'File Removal Failed, File non-existent: {file_path}'
-        print_api(message, error_type=True, logger_method='critical', **kwargs)
+        print_api.print_api(message, error_type=True, logger_method='critical', **kwargs)
         return False
 
 
@@ -321,12 +320,12 @@ def remove_directory(directory_path: str, force_readonly: bool = False, print_kw
             shutil.rmtree(directory_path, onerror=remove_readonly)
         else:
             shutil.rmtree(directory_path)
-        print_api(f'Directory Removed: {directory_path}', **print_kwargs)
+        print_api.print_api(f'Directory Removed: {directory_path}', **print_kwargs)
         return True
     # Since the directory doesn't exist, we actually don't care, since we want to remove it anyway.
     except FileNotFoundError:
         message = f'Directory Removal Failed, Directory non-existent: {directory_path}'
-        print_api(message, error_type=True, logger_method='critical', **print_kwargs)
+        print_api.print_api(message, error_type=True, logger_method='critical', **print_kwargs)
         return False
 
 
@@ -878,7 +877,7 @@ def get_paths_from_directory(
             prefix_string = 'Reading File: '
 
         for file_index, file_path in enumerate(object_list):
-            print_status_of_list(
+            print_api.print_status_of_list(
                 list_instance=object_list, prefix_string=prefix_string, current_state=(file_index + 1))
 
             # If 'add_binary' was passed.

atomicshop/http_parse.py

@@ -1,8 +1,8 @@
-# v1.0.1 - 26.03.2023 23:40
 from http.server import BaseHTTPRequestHandler
 from http.client import HTTPResponse
 import http
 from io import BytesIO
+import socket
 
 
 class HTTPRequestParse(BaseHTTPRequestHandler):
@@ -49,41 +49,27 @@ class HTTPRequestParse(BaseHTTPRequestHandler):
             client_message.request_raw_decoded = request_decoded
     """
 
+    # noinspection PyMissingConstructor
     def __init__(self, request_text):
-        self.rfile = BytesIO(request_text)
-        self.raw_requestline = self.rfile.readline()
-        self.error_code = self.error_message = None
-        self.parse_request()
+        self.request_text = request_text
 
-        # Check if ".path" attribute exists after HTTP request parsing
-        if not hasattr(self, 'path'):
-            self.path = None
+        # noinspection PyTypeChecker
+        self.rfile = None
+        self.raw_requestline = None
+        self.error_code = None
+        self.error_message = None
 
-        # Before checking for body, we need to make sure that ".headers" property exists, if not, return empty values
-        try:
-            # The "body" of request is in the 'Content-Length' key. If it exists in "headers" - get the body
-            if 'Content-Length' in self.headers.keys():
-                # "self.headers.get('Content-Length')" returns number in string format, "int" converts it to integer
-                self.content_length = int(self.headers.get('Content-Length'))
-                self.body = self.rfile.read(self.content_length)
-            else:
-                self.content_length = None
-                self.body = None
-        except Exception:
-            self.content_length = None
-            self.body = None
-            pass
-
-        # Examples:
-        # Getting path: self.path
-        # Getting Request Version: self.request_version
-        # Getting specific header: self.headers['host']
+        self.content_length = None
+        self.body = None
+        # noinspection PyTypeChecker
+        self.path = None
 
+    # noinspection PyMethodOverriding
     def send_error(self, code, message):
         self.error_code = code
         self.error_message = message
 
-    def check_if_http(self):
+    def parse(self):
         """
         Function to check if parsed object is HTTP request or not.
         'reason' will be populated with parsing status and errors.
@@ -117,10 +103,27 @@ class HTTPRequestParse(BaseHTTPRequestHandler):
 
             client_message.request_raw_decoded = request_decoded
         """
-        # Defining variables
-        reason = None
-        function_result: bool = True
-        error: bool = False
+
+        error: str = str()
+        info: str = str()
+
+        self.rfile = BytesIO(self.request_text)
+        self.raw_requestline = self.rfile.readline()
+        self.error_code = self.error_message = None
+        self.parse_request()
+
+        # Before checking for body, we need to make sure that ".headers" property exists, if not, return empty values.
+        if hasattr(self, 'headers'):
+            # The "body" of request is in the 'Content-Length' key. If it exists in "headers" - get the body
+            if 'Content-Length' in self.headers.keys():
+                # "self.headers.get('Content-Length')" returns number in string format, "int" converts it to integer
+                self.content_length = int(self.headers.get('Content-Length'))
+                self.body = self.rfile.read(self.content_length)
+
+        # Examples:
+        # Getting path: self.path
+        # Getting Request Version: self.request_version
+        # Getting specific header: self.headers['host']
 
         # If there's any error in HTTP parsing
         if self.error_message:
@@ -129,65 +132,82 @@ class HTTPRequestParse(BaseHTTPRequestHandler):
                 # If it's 'Bad request' this is not HTTP request, so we can
                 # continue the execution and parse the code as NON-HTTP Request.
                 # Currently, seen 'Bad request syntax' and 'Bad request version'.
-                reason = f"HTTP Request Parsing: Not HTTP request: {self.error_message}"
-                function_result = False
-                error: False
+                error = f"HTTP Request Parsing: Not HTTP request: {self.error_message}"
+                is_http = False
             else:
-                reason = f"HTTP Request Parsing: HTTP Request with Script Undocumented ERROR: {self.error_message}"
-                function_result = True
-                error = True
+                error = f"HTTP Request Parsing: HTTP Request with Script Undocumented ERROR: {self.error_message}"
+                is_http = False
         # If there's no error at all in HTTP Parsing, then it's fine HTTP Request
         else:
-            reason = "HTTP Request Parsing: Valid HTTP request"
-            function_result = True
-            error = False
+            is_http = True
+            info = "HTTP Request Parsing: Valid HTTP request"
 
-        return function_result, reason, error
+        return self, is_http, info, error
 
 
 class FakeSocket:
     """
-    FakeSocket is needed to parse HTTP Response. Socket object is needed for HTTPResponse class input.
+    FakeSocket mimics a socket object for parsing HTTP responses.
     """
     def __init__(self, response_bytes):
         self._file = BytesIO(response_bytes)
 
-    def makefile(self, *args, **kwargs):
+    def makefile(self, mode='rb', buffering=-1) -> BytesIO:
+        """
+        Mimics the socket's makefile method, returning the BytesIO object.
+        """
         return self._file
 
+    def fileno(self) -> int:
+        """
+        Provide a dummy file descriptor, as some code might call this.
+        """
+        raise OSError("File descriptor not available in FakeSocket")
+
 
 class HTTPResponseParse:
     def __init__(self, response_raw_bytes: bytes):
-        self.error = None
         self.response_raw_bytes: bytes = response_raw_bytes
+
+        self.error = None
+        self.source = None
+        self.response_raw_decoded = None
+        self.is_http: bool = False
+
+    def parse(self):
         # Assigning FakeSocket with response_raw_bytes.
         self.source = FakeSocket(self.response_raw_bytes)
 
         # Initializing HTTPResponse class with the FakeSocket with response_raw_bytes as input.
+        # noinspection PyTypeChecker
         self.response_raw_decoded = HTTPResponse(self.source)
 
         # Try to parse HTTP Response.
         try:
             self.response_raw_decoded.begin()
+            self.is_http = True
         # If there were problems with the status line.
         except http.client.BadStatusLine:
             self.error = "HTTP Response Parsing: Not a valid HTTP Response: Bad Status Line."
-            pass
+            self.is_http = False
 
-        try:
-            # If no exception was thrown, but there are some problems with headers.
-            if self.response_raw_decoded.headers.defects:
-                self.error = f"HTTP Response Parsing: Not a valid HTTP Response: Some defects in headers: " \
-                             f"{self.response_raw_decoded.headers.defects}"
-        # If the attribute of defects doesn't exist, probably the response wasn't parsed at all by the library,
-        # Meaning, that the exception was already handled.
-        except AttributeError:
-            pass
-
-        # Before checking for body, we need to make sure that ".headers" property exists, if not, return empty values
-        try:
-            # The "body" of response is in the 'Content-Length' key. If it exists in "headers" - get the body.
-            if 'Content-Length' in self.response_raw_decoded.headers.keys():
+        header_exists: bool = False
+        if (self.response_raw_decoded is not None and hasattr(self.response_raw_decoded, 'headers') and
+                self.response_raw_decoded.headers is not None):
+            header_exists = True
+
+        if header_exists and self.response_raw_decoded.headers.defects:
+            self.error = f"HTTP Response Parsing: Not a valid HTTP Response: Some defects in headers: " \
+                         f"{self.response_raw_decoded.headers.defects}"
+            self.is_http = False
+
+        if self.is_http:
+            # Before checking for body, we need to make sure that ".headers" property exists,
+            # if not, return empty values.
+            self.response_raw_decoded.content_length = None
+            self.response_raw_decoded.body = None
+            if header_exists and 'Content-Length' in self.response_raw_decoded.headers.keys():
+                # The "body" of response is in the 'Content-Length' key. If it exists in "headers" - get the body.
                 # "self.response_raw_decoded.headers.get('Content-Length')" returns number in string format,
                 # "int" converts it to integer.
                 self.response_raw_decoded.content_length = int(self.response_raw_decoded.headers.get('Content-Length'))
@@ -195,10 +215,5 @@ class HTTPResponseParse:
                 # of the response that we received.
                 # self.response_raw_bytes[-23:]
                 self.response_raw_decoded.body = self.response_raw_bytes[-self.response_raw_decoded.content_length:]
-            else:
-                self.response_raw_decoded.content_length = None
-                self.response_raw_decoded.body = None
-        except Exception:
-            self.response_raw_decoded.content_length = None
-            self.response_raw_decoded.body = None
-            pass
+
+        return self.response_raw_decoded, self.is_http, self.error