atomicshop 2.6.8__py3-none-any.whl → 2.6.10__py3-none-any.whl

atomicshop/archiver/zip.py

@@ -0,0 +1,283 @@
+import os
+import time
+import zipfile
+
+from .. import filesystem
+from ..print_api import print_api
+
+
+def is_zip_zipfile(file_path: str) -> bool:
+    """
+    Function checks if the file is a zip file.
+    :param file_path: string, full path to the file.
+    :return: boolean.
+    """
+
+    try:
+        with zipfile.ZipFile(file_path) as zip_object:
+            zip_object.testzip()
+            return True
+    except zipfile.BadZipFile:
+        return False
+
+
+def is_zip_magic_number(file_path: str) -> bool:
+    """
+    Function checks if the file is a zip file using magic number.
+    :param file_path: string, full path to the file.
+    :return: boolean.
+
+    50 4B 03 04: This is the most common signature, found at the beginning of a ZIP file.
+        It signifies the start of a file within the ZIP archive and is present in almost all ZIP files.
+        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.
+    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.
+    """
+
+    with open(file_path, 'rb') as file:
+        # Read the first 4 bytes of the file
+        signature = file.read(4)
+
+    # Check if the signature matches any of the ZIP signatures
+    return signature in [b'PK\x03\x04', b'PK\x05\x06', b'PK\x07\x08']
+
+
+def extract_archive_with_zipfile(
+        archive_path: str,
+        extract_directory: str = None,
+        files_without_directories: bool = False,
+        remove_first_directory: bool = False,
+        print_kwargs: dict = None
+) -> str:
+    """
+    Function will extract the archive using standard library 'zipfile'.
+    This method preserves original date and time of the files inside the archive.
+
+    :param archive_path: string, full path to archived file.
+    :param extract_directory: string, full path to directory that the files will be extracted to.
+        If not specified, the files will be extracted to the same directory as the archived file, using the file name
+        without extension as the directory name.
+    :param files_without_directories: boolean, default 'False'.
+        'True': All the files in the archive will be extracted without subdirectories hierarchy.
+            Meaning, that if there are duplicate file names, the latest file with the same file name will overwrite
+            all the rest of the files with the same name.
+        'False': Subdirectory hierarchy will be preserved as it is currently in the archived file.
+    :param remove_first_directory: boolean, default is 'False'.
+        'True': all the files will be extracted without first directory in the hierarchy.
+            Example: package_some_name_1.1.1_build/subdir1/file.exe
+            Will be extracted as: subdir/file.exe
+    :param print_kwargs: dict, kwargs for print_api.
+
+    :return: string, full path to directory that the files were extracted to.
+    """
+
+    if print_kwargs is None:
+        print_kwargs = dict()
+
+    # If 'extract_directory' is not specified, extract to the same directory as the archived file.
+    if extract_directory is None:
+        extract_directory = (
+                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)
+
+    # initiating the archived file path as 'zipfile.ZipFile' object.
+    with zipfile.ZipFile(archive_path) as zip_object:
+        # '.infolist()' method of the object contains all the directories and files that are in the archive including
+        # information about each one, like date and time of archiving.
+        for zip_info in zip_object.infolist():
+            # '.filename' attribute of the 'infolist()' method is relative path to each directory and file.
+            # If 'filename' ends with '/' it is a directory (it doesn't matter if it is windows or *nix)
+            # If so, skip current iteration.
+            if zip_info.filename[-1] == '/':
+                continue
+
+            if files_without_directories:
+                # Put into 'filename' the string that contains only the filename without subdirectories.
+                zip_info.filename = os.path.basename(zip_info.filename)
+            elif remove_first_directory:
+                # 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)
+
+            # Extract current file from the archive using 'zip_info' of the current file with 'filename' that we
+            # updated under specified parameters to specified directory.
+            zip_object.extract(zip_info, extract_directory)
+
+            # === Change the date and time of extracted file from current time to the time specified in 'zip_info'.
+            # Get full path to extracted file.
+            extracted_file_path: str = extract_directory + os.sep + zip_info.filename
+            # Create needed datetime object with original archived datetime from 'zip_info.date_time'.
+            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)
+
+    return extract_directory
+
+
+def get_file_list_from_zip(file_path: str) -> list:
+    """
+    Function returns the list of file names and their relative directories inside the zip file.
+    :param file_path: string, full path to the zip file.
+    :return: list of strings.
+    """
+
+    with zipfile.ZipFile(file_path, 'r') as zip_object:
+        return zip_object.namelist()
+
+
+# def search_file_in_zip(
+#         file_path: str = None,
+#         file_bytes: bytes = None,
+#         file_names_to_search: list[str] = None,
+#         case_sensitive: bool = True,
+#         return_first_only: bool = False,
+#         return_empty_list_per_file_name: bool = False,
+#         recursive: bool = False,
+#         callback_functions: list = None,
+#         extract_file_to_path: str = None
+# ) -> dict[str, list[bytes]]:
+#     """
+#     Function searches for the file names inside the zip file and returns a dictionary where the keys are the
+#     names of the callback functions and the values are lists of found file bytes.
+#     :param file_path: string, full path to the zip file.
+#     :param file_bytes: bytes, the bytes of the zip file.
+#     :param file_names_to_search: list of strings, the names of the files to search.
+#     :param case_sensitive: boolean, default is 'True'. Determines if file name search should be case sensitive.
+#     :param return_first_only: boolean, default is 'False'. Return only the first found file for each file name.
+#     :param return_empty_list_per_file_name: boolean, default is 'False'.
+#         True: Return empty list for each file name that wasn't found.
+#         False: Don't return empty list for each file name that wasn't found.
+#     :param recursive: boolean, default is 'False'. If True, search for file names recursively in nested zip files.
+#     :param callback_functions: list of callables, default is None. Each function takes a file name and should return a
+#         boolean that will tell the main function if this file is 'found' or not.
+#     :param extract_file_to_path: string, full path to the directory where the found files should be extracted.
+#     :return: dictionary of lists of bytes.
+#     """
+#
+#     def get_unique_filename(directory, filename):
+#         """
+#         Generates a unique filename by appending a number if the file already exists.
+#         """
+#         name, ext = os.path.splitext(filename)
+#         counter = 1
+#         unique_filename = filename
+#         while os.path.exists(os.path.join(directory, unique_filename)):
+#             unique_filename = f"{name}_{counter}{ext}"
+#             counter += 1
+#         return unique_filename
+#
+#     def is_zip_file(file, zip_obj):
+#         try:
+#             with zip_obj.open(file) as file_data:
+#                 with zipfile.ZipFile(BytesIO(file_data.read())) as zip_file:
+#                     if zip_file.testzip() is None:  # No errors found
+#                         return True
+#         except zipfile.BadZipFile:
+#             return False
+#         return False
+#
+#     def match_file_name(target, current):
+#         if case_sensitive:
+#             return current.endswith(target)
+#         else:
+#             return current.lower().endswith(target.lower())
+#
+#     def search_in_zip(zip_obj, file_names, results, found_set):
+#         for item in zip_obj.infolist():
+#             if item.filename.endswith('/'):  # Skip directories
+#                 continue
+#             is_nested_zip = recursive and is_zip_file(item.filename, zip_obj)
+#
+#             with zip_obj.open(item) as file_data:
+#                 archived_file_bytes = file_data.read()
+#
+#                 # This is needed to know if the file should be extracted to directory or not.
+#                 should_extract = False
+#
+#                 name_matched = False
+#                 if file_names is not None:
+#                     name_matched = any(match_file_name(file_name, item.filename) for file_name in file_names)
+#                     if name_matched:
+#                         should_extract = True
+#
+#                 callback_matched = False
+#                 if callback_functions:
+#                     for callback in callback_functions:
+#                         callback_result = callback(archived_file_bytes)
+#                         if callback_result:
+#                             callback_matched = True
+#                             # Initialize key for callback function name if not present
+#                             if callback.__name__ not in results:
+#                                 results[callback.__name__] = []
+#                             file_info = {
+#                                 'bytes': archived_file_bytes,
+#                                 'name': item.filename,
+#                                 'size': item.file_size,
+#                                 'modified_time': item.date_time
+#                             }
+#                             results[callback.__name__].append(file_info)
+#                             if return_first_only:
+#                                 found_set.add(item.filename)
+#
+#                             should_extract = True
+#                             break  # Stop checking other callbacks if one has found it
+#
+#                 if should_extract and extract_file_to_path:
+#                     unique_filename = get_unique_filename(extract_file_to_path, os.path.basename(item.filename))
+#                     with open(os.path.join(extract_file_to_path, unique_filename), 'wb') as f:
+#                         f.write(archived_file_bytes)
+#
+#                 if not callback_matched:
+#                     if is_nested_zip:
+#                         # If the file is a nested ZIP and hasn't matched a callback, search recursively
+#                         nested_zip_bytes = BytesIO(archived_file_bytes)
+#                         with zipfile.ZipFile(nested_zip_bytes) as nested_zip:
+#                             search_in_zip(nested_zip, file_names, results, found_set)
+#                     elif name_matched:
+#                         # Handle name match when no callbacks are provided or no callback matched
+#                         if item.filename not in results:
+#                             results[item.filename] = []
+#                         file_info = {
+#                             'bytes': archived_file_bytes,
+#                             'name': item.filename,
+#                             'size': item.file_size,
+#                             'modified_time': item.date_time
+#                         }
+#                         results[item.filename].append(file_info)
+#                         if return_first_only:
+#                             found_set.add(item.filename)  # Mark as found
+#
+#                 if file_names is not None and len(found_set) == len(file_names):
+#                     return  # All files found, stop searching
+#
+#     if file_names_to_search is None and callback_functions is None:
+#         raise ValueError("Either file_names_to_search or callback_functions must be provided.")
+#
+#     # Initialize results dictionary.
+#     if callback_functions:
+#         results = {callback.__name__: [] for callback in callback_functions}
+#     else:
+#         results = {}
+#
+#     found_set = set()
+#     if file_bytes is not None:
+#         with zipfile.ZipFile(BytesIO(file_bytes), 'r') as zip_ref:
+#             search_in_zip(zip_ref, file_names_to_search, results, found_set)
+#     elif file_path is not None:
+#         with zipfile.ZipFile(file_path, 'r') as zip_ref:
+#             search_in_zip(zip_ref, file_names_to_search, results, found_set)
+#     else:
+#         raise ValueError("Either file_path or file_bytes must be provided.")
+#
+#     if not return_empty_list_per_file_name:
+#         # Filter out keys with empty lists
+#         results = {key: value for key, value in results.items() if value}
+#
+#     return results

atomicshop/basics/bytes_arrays.py

@@ -53,18 +53,26 @@ def convert_sequence_of_bytes_to_sequence_of_strings(byte_sequence: bytes) -> li
     return result
 
 
-def find_position(file_path: str, target: bytes, chunk_size: int = None, starting_position: int = 0) -> int:
+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.
 
-    :param file_path: string, path to file.
     :param target: bytes, target bytes string.
+    :param file_path: string, path to file.
+    :param file_bytes: bytes, bytes string of the file.
     :param chunk_size: integer, chunk size  in bytes.
     :param starting_position: integer, starting position in bytes. You can specify the starting seeking point
         in the file.
     :return:
     """
 
+    def read_chunk(position):
+        if file_path:
+            return file.read(chunk_size)
+        else:
+            end_position = min(position + chunk_size, len(file_bytes))
+            return file_bytes[position:end_position]
+
     if not chunk_size:
         chunk_size = len(target)
 
@@ -73,12 +81,23 @@ def find_position(file_path: str, target: bytes, chunk_size: int = None, startin
     # Overlap between chunks to ensure target isn't split between chunks
     overlap_size = len(target) - 1
 
-    with open(file_path, 'rb') as file:
+    # Update the position variable to match the starting position.
+    position = starting_position
+
+    # Check if file_bytes is provided, otherwise read from the file path
+    if file_bytes is not None:
+        file = file_bytes
+        length = len(file_bytes)
+    else:
+        if not file_path:
+            raise ValueError("Either file_path or file_bytes must be provided.")
+        file = open(file_path, 'rb')
         # Move the file cursor to the starting position.
         file.seek(starting_position)
-        # Update the position variable to match the starting position.
-        position = starting_position
-        chunk = file.read(chunk_size)
+
+    # try-finally block to ensure the file is closed properly if opened.
+    try:
+        chunk = read_chunk(position)
 
         while chunk:
             index = chunk.find(target)
@@ -86,25 +105,50 @@ def find_position(file_path: str, target: bytes, chunk_size: int = None, startin
                 # Return the absolute position of the target in the file
                 return position + index
 
-            # Move the file cursor back by the overlap size to ensure target isn't split between chunks
-            file.seek(position + chunk_size - overlap_size)
+            # Move the file cursor back by the overlap size to ensure target isn't split between chunks.
             # Get the current position of the cursor in the file.
-            position = file.tell()
-            chunk = file.read(chunk_size)
+
+            # Update position differently depending on the input type
+            if file_path:
+                position = file.tell() - overlap_size
+                file.seek(position)
+            else:
+                position += chunk_size - overlap_size
+
+            chunk = read_chunk(position)
+
+    finally:
+        if file_path:
+            file.close()
 
     # Return -1 if the target is not found
     return -1
 
 
-def read_bytes_from_position(file_path: str, starting_position: int, num_bytes: int) -> bytes:
+def read_bytes_from_position(
+        starting_position: int,
+        num_bytes: int,
+        file_path: str = None,
+        file_bytes: bytes = None
+) -> bytes:
     """
     Read bytes from specified position in the file.
-    :param file_path: string, path to file.
     :param starting_position: integer, starting position in bytes.
     :param num_bytes: integer, number of bytes to read.
+    :param file_path: string, path to file.
+    :param file_bytes: bytes, bytes string of the file.
     :return: bytes.
     """
 
+    if not file_path and not file_bytes:
+        raise ValueError("Either file_path or file_bytes must be provided.")
+
+    if file_bytes is not None:
+        # Ensure starting position and number of bytes are within the length of file_bytes
+        if starting_position < 0 or starting_position + num_bytes > len(file_bytes):
+            raise ValueError("Starting position and number of bytes to read are out of bounds.")
+        return file_bytes[starting_position:starting_position + num_bytes]
+
     with open(file_path, 'rb') as file:
         # Move the file cursor to the specified position.
         file.seek(starting_position)

atomicshop/file_io/jsons.py

@@ -96,3 +96,14 @@ def convert_dict_to_json_string(
         indent = 2
 
     return json.dumps(dict_or_list, indent=indent)
+
+
+def convert_json_string_to_dict(json_string: str) -> dict:
+    """
+    Convert json formatted string to dictionary.
+
+    :param json_string: json formatted string.
+    :return: dictionary.
+    """
+
+    return json.loads(json_string)

atomicshop/file_io/xmls.py

@@ -1,14 +1,15 @@
 import xml.etree.ElementTree as ET
 
 
-def read_xml_file(
-        file_path: str,
-        **kwargs):
+def read_xml(
+        file_path: str = None,
+        xml_bytes: bytes = None,
+):
     """
-    Read the xml file and return its content as dictionary.
-    :param file_path: string, full path to xml file.
-    :param kwargs: dict, keyword arguments for print_api function.
-    :return:
+    Read XML from a file or bytes and return its content as a dictionary.
+    :param file_path: Optional string, full path to xml file.
+    :param xml_bytes: Optional bytes, XML data as bytes.
+    :return: Tuple containing the XML dictionary, the ElementTree, and the root element.
     """
 
     def xml_to_dict(element):
@@ -40,8 +41,18 @@ def read_xml_file(
 
         return element_dict
 
-    tree = ET.parse(file_path)
-    root = tree.getroot()
+    # Determine source of XML data
+    if xml_bytes is not None:
+        # Parse XML from bytes object
+        root = ET.fromstring(xml_bytes)
+        tree = ET.ElementTree(root)
+    elif file_path is not None:
+        # Parse XML from file
+        tree = ET.parse(file_path)
+        root = tree.getroot()
+    else:
+        raise ValueError("Either file_path or xml_bytes must be provided")
+
     result_xml_dict: dict = xml_to_dict(root)
 
     return result_xml_dict, tree, root

atomicshop/web.py

@@ -2,7 +2,7 @@ import os
 import urllib.request
 
 from .print_api import print_api
-from .archiver import extract_archive_with_zipfile
+from .archiver import zip
 from .urls import url_parser
 from .file_io import file_io
 from .wrappers.playwrightw import scenarios
@@ -239,7 +239,7 @@ def download_and_extract_file(
         file_url=file_url, target_directory=target_directory, file_name=file_name, **kwargs)
 
     # Extract the archive and remove the first directory.
-    extract_archive_with_zipfile(
+    zip.extract_archive_with_zipfile(
         archive_path=f'{file_path}', extract_directory=target_directory,
         remove_first_directory=archive_remove_first_directory, **kwargs)
 

atomicshop/wrappers/configparserw.py

@@ -1,6 +1,7 @@
 import os
 import configparser
 from typing import Any
+import io
 
 from ..print_api import print_api
 from ..basics import lists
@@ -12,7 +13,13 @@ class ConfigParserWrapper:
     ImportConfig class is responsible for importing 'config.ini' file and its variables.
     """
 
-    def __init__(self, file_name: str = 'config.ini', directory_path: str = None, file_path: str = None):
+    def __init__(
+            self,
+            file_name: str = 'config.ini',
+            directory_path: str = None,
+            file_path: str = None,
+            config_content: str = None
+    ):
         """
         The function will initialize the 'ImportConfig' object.
         You can specify either full 'file_path' or 'directory_path' and 'file_name'.
@@ -21,16 +28,18 @@ class ConfigParserWrapper:
         :param file_name: The name of the file to be imported. Default is 'config.ini'.
         :param directory_path: The directory that 'config.ini' file is in.
         :param file_path: sting, the full path to the file.
+        :param config_content: string, the content of the config file. If specified, the 'file_path' will be ignored.
         """
 
-        if not directory_path and not file_path:
-            raise ValueError("You must specify either 'directory_path' or 'file_path'.")
-        elif directory_path and file_path:
-            raise ValueError("You can't specify both 'directory_path' and 'file_path'.")
+        if not directory_path and not file_path and not config_content:
+            raise ValueError("You must specify either 'directory_path' or 'file_path' or 'config_content'.")
+        elif (directory_path and file_path) or (directory_path and config_content) or (file_path and config_content):
+            raise ValueError("You can't specify both 'directory_path' and 'file_path' or 'config_content'.")
 
         self.file_name: str = file_name
         self.directory_path: str = directory_path
         self.file_path: str = file_path
+        self.config_content: str = config_content
 
         self.config_parser = None
         # Final configuration dictionary.
@@ -38,7 +47,7 @@ class ConfigParserWrapper:
 
         if file_path:
             self.file_path: str = file_path
-        else:
+        elif directory_path:
             self.file_path: str = self.directory_path + os.sep + self.file_name
 
         # After that you can use 'convert_string_values' function to convert certain key values to other types.
@@ -208,11 +217,15 @@ class ConfigParserWrapper:
         if not self.config_parser:
             self.initialize_config_parser()
 
-        if not unicode_encoding:
-            self.config_parser.read(self.file_path)
-        else:
-            # Reading with 'utf-8' (non ansi languages):
-            self.config_parser.read(self.file_path, encoding='utf-8')
+        if self.file_path:
+            if not unicode_encoding:
+                self.config_parser.read(self.file_path)
+            else:
+                # Reading with 'utf-8' (non ansi languages):
+                self.config_parser.read(self.file_path, encoding='utf-8')
+        elif self.config_content:
+            config_io = io.StringIO(self.config_content)
+            self.config_parser.read_file(config_io)
 
         # If there are no sections in the configparser object, that means there really no sections, or the file
         # doesn't exist. ConfigParser doesn't check the file for existence.

atomicshop/wrappers/factw/config_install.py

@@ -10,3 +10,5 @@ PRE_INSTALL_FILE_PATH: str = SRC_DIRECTORY_PATH + os.sep + 'install' + os.sep +
 # After restart.
 INSTALL_LOG_FILE_NAME: str = 'install.log'
 INSTALL_FILE_PATH: str = SRC_DIRECTORY_PATH + os.sep + 'install.py'
+
+FACT_EXTRACTOR_FILE_NAME: str = 'extract.py'

atomicshop/wrappers/githubw.py

@@ -67,8 +67,8 @@ class GitHubWrapper:
 
         :param target_directory:
         :param archive_remove_first_directory: boolean, sets if archive extract function will extract the archive
-            without first directory in the archive. Check reference in the 'archiver.extract_archive_with_zipfile'
-            function.
+            without first directory in the archive. Check reference in the
+            'archiver.zip.extract_archive_with_zipfile' function.
         :return:
         """
 

{atomicshop-2.6.8.dist-info → atomicshop-2.6.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.6.8
+Version: 2.6.10
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License: MIT License
@@ -45,6 +45,7 @@ Requires-Dist: playwright
 Requires-Dist: playwright-stealth
 Requires-Dist: protobuf
 Requires-Dist: psutil
+Requires-Dist: py7zr
 Requires-Dist: pyautogui
 Requires-Dist: pyopenssl
 Requires-Dist: python-bidi
@@ -114,7 +115,7 @@ Currently, the library is being developed on Windows 10 and python 3.11. No othe
 This means that the official support of the library is mainly for python 3.11 under Windows 10.
 Most of the features will work, but some require at least version 3.10, like SocketWrapper. Since, some features in it are 3.10 specific.
 
-The library and its features will evolve based on my curiosity and needs. But as of now, the updates to features list are almost on daily basis.
+The library and its features will evolve based on my curiosity and needs. But as of now, the updates to features list are relatively frequent.
 
 
 <!-- GETTING STARTED -->