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

atomicshop/addons/mains/install_docker_ubuntu_main_sudo.py

@@ -2,7 +2,8 @@ from atomicshop.wrappers.dockerw import install_docker
 
 
 def main():
-    install_docker.install_docker_ubuntu()
+    install_docker.install_docker_ubuntu(
+        use_docker_installer=True, rootless=False, add_current_user_to_docker_group_bool=True)
 
 
 if __name__ == '__main__':

atomicshop/addons/mains/msi_unpacker.py

@@ -0,0 +1,5 @@
+from atomicshop.wrappers.ctyping.msi_windows_installer import extract_msi_main
+
+
+if __name__ == "__main__":
+    extract_msi_main.extract_files_from_msi_main()

atomicshop/archiver/sevenz_app_w.py

@@ -0,0 +1,86 @@
+import os
+import subprocess
+from pathlib import Path
+
+from ..print_api import print_api
+from .. import process, filesystem
+
+
+def is_path_contains_7z_executable(sevenz_path: str) -> bool:
+    """
+    Checks if the path contains 7z executable.
+    :param sevenz_path: string, The path to the 7z executable.
+    :return: bool, True if the path contains 7z executable, False otherwise.
+    """
+    executable_path_parts: tuple = Path(sevenz_path).parts
+
+    if '7z' not in executable_path_parts[-1]:
+        return False
+    else:
+        return True
+
+
+def is_executable_a_7z(sevenz_path: str) -> bool:
+    """
+    Checks if the 7z executable is installed.
+    :param sevenz_path: string, The path to the 7z executable.
+    :return: bool, True if the 7z executable is installed, False otherwise.
+    """
+
+    # Check if the process itself is installed.
+    if process.is_command_exists(sevenz_path):
+        # Check that this is the 7z executable.
+        try:
+            # Run '7z' command and capture output
+            result = subprocess.run([sevenz_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+            # Check if the output contains identifying information
+            if b"7-Zip" in result.stdout or b"7-Zip" in result.stderr:
+                return True
+        except Exception:
+            return False
+
+        return False
+
+
+def extract_file(
+        file_path: str,
+        extract_to: str,
+        sevenz_path: str = None,
+        force_overwrite: bool = False,
+        print_kwargs: dict = None
+):
+    """
+    Extracts a file to a directory using 7z executable.
+    :param file_path: string, The path to the file to extract.
+    :param extract_to: string, The directory to extract the file to.
+    :param sevenz_path: string, The path to the 7z executable.
+        If None, the default path is used, assuming you added 7z to the PATH environment variable.
+    :param force_overwrite: bool, If True, the files will be overwritten if they already exist in the output folder.
+    :param print_kwargs: dict, The keyword arguments to pass to the print function.
+    :return:
+    """
+
+    # Check if the path contains 7z executable.
+    if not is_path_contains_7z_executable(sevenz_path):
+        raise ValueError("The path to 7z does not contain 7z executable")
+
+    if not sevenz_path:
+        sevenz_path = '7z'
+
+    # Check if the 7z executable is installed.
+    if not is_executable_a_7z(sevenz_path):
+        raise RuntimeError("'7z executable' is not a 7z")
+
+    if not os.path.exists(extract_to):
+        os.makedirs(extract_to)
+
+    command = [f'{sevenz_path}', 'x', file_path, f'-o{extract_to}']
+    if force_overwrite:
+        command.append('-y')
+
+    try:
+        subprocess.run(command, check=True)
+        print_api(f"Extracted {file_path} to {extract_to}", **(print_kwargs or {}))
+    except subprocess.CalledProcessError as e:
+        print_api(f"An error occurred: {e}", **(print_kwargs or {}))

atomicshop/process.py

@@ -3,6 +3,7 @@ import functools
 from typing import Union
 import shlex
 import subprocess
+import shutil
 
 from .print_api import print_api
 from .inspect_wrapper import get_target_function_default_args_and_combine_with_current
@@ -12,6 +13,23 @@ if os.name == 'nt':
     from .process_poller import GetProcessList
 
 
+def is_command_exists(cmd: str) -> bool:
+    """
+    The function checks if the command exists in the system.
+    :param cmd: string, the command to check.
+    :return: bool, True if the command exists, False otherwise.
+
+    With this you can also check if the command is in the PATH environment variable.
+    Example:
+    print(is_command_exists('7z'))  # C:\\Program Files\\7-Zip\\7z.exe
+    """
+
+    if shutil.which(cmd):
+        return True
+    else:
+        return False
+
+
 def process_execution_decorator(function_name):
     @functools.wraps(function_name)
     def wrapper_process_execution_decorator(*args, **kwargs):

atomicshop/wrappers/ctyping/msi_windows_installer/base.py

@@ -0,0 +1,134 @@
+from typing import Literal
+import ctypes
+from ctypes import wintypes
+
+
+# Load Windows Installer functions
+msi = ctypes.windll.msi
+
+
+# Constants
+MSIDBOPEN_READONLY = 0
+ERROR_NO_MORE_ITEMS = 259
+
+
+def create_open_db_handle(msi_filepath):
+    """Create a database handle for the specified MSI file."""
+    db_handle = ctypes.c_void_p()
+
+    result = msi.MsiOpenDatabaseW(msi_filepath, MSIDBOPEN_READONLY, ctypes.byref(db_handle))
+    if result != 0:
+        print(f"Failed to open MSI database. Error code: {result}")
+        raise ctypes.WinError(result)
+    return db_handle
+
+
+def create_open_execute_view_handle(db_handle, query):
+    """Create a view handle for the specified query."""
+    # Create view handle.
+    view_handle = ctypes.c_void_p()
+
+    # Open the view.
+    result = msi.MsiDatabaseOpenViewW(db_handle, query, ctypes.byref(view_handle))
+    if result != 0:
+        print(f"Failed to open view. Error code: {result}")
+        msi.MsiCloseHandle(db_handle)
+        raise ctypes.WinError(result)
+
+    # Execute the view.
+    result = msi.MsiViewExecute(view_handle, None)
+    if result != 0:
+        print(f"Failed to execute view. Error code: {result}")
+        msi.MsiCloseHandle(view_handle)
+        msi.MsiCloseHandle(db_handle)
+        raise ctypes.WinError(result)
+
+    return view_handle
+
+
+def create_fetch_record_from_view_handle(view_handle):
+    """Fetch a record from the specified view handle."""
+    # Fetch the record handle.
+    record_handle = ctypes.c_void_p()
+
+    # Fetch the record.
+    fetch_record_result = msi.MsiViewFetch(view_handle, ctypes.byref(record_handle))
+    if fetch_record_result == ERROR_NO_MORE_ITEMS:
+        msi.MsiCloseHandle(view_handle)
+        return record_handle
+    elif fetch_record_result != 0:
+        print(f"Failed to fetch record. Error code: {fetch_record_result}")
+        msi.MsiCloseHandle(view_handle)
+        raise ctypes.WinError(fetch_record_result)
+
+    return record_handle
+
+
+def get_table_field_data_from_record(
+        record_handle,
+        field_index,
+        data_type: Literal['stringw', 'integer', 'stream'],
+        buffer_size: int = 2048
+):
+    """
+    Read data from a specific field in a record.
+    :param record_handle: Record handle.
+    :param field_index: The field index. Example: 2 for the second field.
+        Name,Data
+        field_index = 1 for Name
+        field_index = 2 for Data
+    :param data_type: The type of data to read.
+        stringw: Read the data as a wide string.
+        integer: Read the data as an integer.
+        stream: Read the data as a binary stream (bytes).
+    :param buffer_size: The size of the buffer to use when reading the data.
+    :return:
+    """
+
+    if data_type == 'stringw':
+        buf_size = wintypes.DWORD(buffer_size)
+        buf = ctypes.create_unicode_buffer(buf_size.value)
+        result = msi.MsiRecordGetStringW(record_handle, field_index, buf, ctypes.byref(buf_size))
+        if result != 0:
+            if result == 234:
+                print("Buffer size too small. Try again with a larger buffer.")
+            print(f"Failed to get string from record. Error code: {result}")
+            msi.MsiCloseHandle(record_handle)
+            raise ctypes.WinError(result)
+        return str(buf.value)
+
+    elif data_type == 'integer':
+        int_value = ctypes.c_int()
+        result = msi.MsiRecordGetInteger(record_handle, field_index, ctypes.byref(int_value))
+        if result != 0:
+            print(f"Failed to get integer from record. Error code: {result}")
+            msi.MsiCloseHandle(record_handle)
+            raise ctypes.WinError(result)
+        return int_value.value
+
+    elif data_type == 'stream':
+        # stream_size = wintypes.DWORD()
+        # result = msi.MsiRecordReadStream(record_handle, field_index, None, ctypes.byref(stream_size))
+        # if result != 0:
+        #     print(f"Failed to read stream data. Error code: {result}")
+        #     msi.MsiCloseHandle(record_handle)
+        #     raise ctypes.WinError(result)
+        #
+        # stream_data = ctypes.create_string_buffer(stream_size.value)
+        # msi.MsiRecordReadStream(record_handle, field_index, stream_data, ctypes.byref(stream_size))
+        # return stream_data.raw
+
+        buffer = ctypes.create_string_buffer(buffer_size)
+        read_size = wintypes.DWORD(buffer_size)
+        data = bytearray()
+
+        while True:
+            result = msi.MsiRecordReadStream(record_handle, field_index, buffer, ctypes.byref(read_size))
+            if result != 0 or read_size.value == 0:
+                break
+            data.extend(buffer.raw[:read_size.value])
+
+        return data
+
+    else:
+        raise ValueError(f"Invalid data type: {data_type}. Valid options are 'stringw', 'integer', 'stream'.")

atomicshop/wrappers/ctyping/msi_windows_installer/cabs.py

@@ -0,0 +1,75 @@
+import os
+from pathlib import Path
+
+from . import tables
+from ....archiver import sevenz_app_w
+
+
+def resolve_directory_path(directory_info, directory_key):
+    parts = []
+    current_key = directory_key
+    while current_key:
+        entry = directory_info.get(current_key)
+        if entry:
+            parts.append(entry['default_dir'])
+            current_key = entry['parent']
+        else:
+            break
+    if not parts:
+        return ""
+    return str(os.path.join(*reversed(parts)))
+
+
+def rename_extracted_files_by_file_table_info(
+        extracted_files_dir, file_table_info, component_table_info, directory_table_info):
+
+    for file_key, info in file_table_info.items():
+        component = info['component']
+        directory_key = component_table_info[component]['directory']
+        resolved_directory_path: str = resolve_directory_path(directory_table_info, directory_key)
+
+        # Divide the path into parts and remove the first part if it is a 'SourceDir' and the last part if it is a dot.
+        resolved_directory_parts = Path(resolved_directory_path).parts
+        if resolved_directory_parts[-1] == '.':
+            resolved_directory_parts = resolved_directory_parts[:-1]
+        if resolved_directory_parts[0] == 'SourceDir':
+            resolved_directory_parts = resolved_directory_parts[1:]
+        resolved_directory_path = str(os.path.join(*resolved_directory_parts))
+
+        extracted_path = os.path.join(extracted_files_dir, file_key)
+        if os.path.exists(extracted_path):
+            new_file_name = f"{info['file_name']}"
+            new_file_path = os.path.join(extracted_files_dir, resolved_directory_path, new_file_name)
+            os.makedirs(os.path.dirname(new_file_path), exist_ok=True)
+            os.rename(extracted_path, new_file_path)
+            print(f"Renamed: [{file_key}] to [{new_file_name}]")
+        else:
+            print(f"File not found: [{file_key}] in {extracted_path}")
+
+
+def extract_files_from_cab(db_handle, main_cab_path: str, output_directory: str, sevenz_path: str = None):
+    """
+    Extracts the files from the CAB file using 7z executable and the MSI database handle to get the real file
+    names and paths.
+    :param db_handle: Database handle to the MSI database.
+    :param main_cab_path: string, The path to the main CAB file.
+    :param output_directory: string, The directory to extract the files to.
+    :param sevenz_path: string, Full path to the 7z executable.
+    :return:
+    """
+
+    # Get all the tables entries from the MSI database to correlate them while building the file paths and renaming.
+    file_table_info = tables.get_file_table_info(db_handle)
+    component_table_info = tables.get_component_table_info(db_handle)
+    directory_table_info = tables.get_directory_table_info(db_handle)
+
+    # Extract the contents of the CAB file (if there are several CAB files, they will be extracted as well).
+    sevenz_app_w.extract_file(
+        file_path=main_cab_path,
+        extract_to=output_directory,
+        sevenz_path=sevenz_path,
+        force_overwrite=True
+    )
+
+    rename_extracted_files_by_file_table_info(
+        output_directory, file_table_info, component_table_info, directory_table_info)

atomicshop/wrappers/ctyping/msi_windows_installer/extract_msi_main.py

@@ -0,0 +1,136 @@
+import os
+import sys
+import argparse
+
+from .base import msi
+from . import base, tables, cabs
+from ... import olefilew
+from ....print_api import print_api
+from ....archiver import sevenz_app_w
+
+
+# Directory names.
+EXTRACTED_FILES: str = "Extracted_MSI_Installation_Files"
+EMBEDDED_FILES: str = "Embedded_MSI_Files"
+CAB_FILES: str = "CAB_Files"
+BINARY_FILES: str = "Binary_Files"
+TABLE_CONTENTS: str = "Table_Contents"
+ICON_FILES: str = "Icon_Files"
+ISSETUPFILES: str = "ISSETUPFILES"
+OLE_METADATA: str = "OLE_Metadata"
+REGISTRY_CHANGES: str = "Registry_Changes"
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Extract files from the MSI file.")
+    parser.add_argument("--msi_filepath", "-m", type=str, help="The path to the MSI file.")
+    parser.add_argument("--output_directory", "-o", type=str, help="The main output directory.")
+    parser.add_argument("--sevenz_path", "-s", type=str, help="The path to the 7z executable.")
+    return parser.parse_args()
+
+
+def extract_files_from_msi_main(
+        msi_filepath: str = None,
+        main_out_directory: str = None,
+        sevenz_path: str = None
+):
+    """
+    Extracts files from the MSI file using the MSI database.
+    What can be extracted:
+    - MSI file Table contents
+    - MSI file Binary files
+    - MSI file Icon files
+    - MSI file ISSETUPFILES
+    - MSI file Registry changes
+    - MSI file CAB files
+    - Application Installation files.
+        These are extracted from the CAB files and renamed to their real names from the DB.
+    - MSI file OLE metadata
+
+    Usage:
+        # You can create a python file with the following content and run it:
+        from atomicshop.wrappers.ctyping.msi_windows_installer import extract_msi_main
+
+
+        if __name__ == "__main__":
+            extract_msi_main.extract_files_from_msi_main()
+
+    Or you can just use the function with the appropriate parameters directly:
+        extract_msi_main.extract_files_from_msi_main(
+            msi_filepath=r"C:\\Setup.msi",
+            main_out_directory=r"c:\\unpacked_msi",
+            sevenz_path=r"C:\\7z.exe")
+
+    :param msi_filepath: string, The path to the MSI file.
+    :param main_out_directory: string, The main output directory.
+    :param sevenz_path: string, The path to the 7z executable. If None, the default path is used, which assumes that 7z
+        is in the PATH environment variable.
+    :return:
+    """
+
+    args = parse_args()
+
+    # If arguments to the function were not provided, use the arguments from the command line.
+    if not msi_filepath:
+        msi_filepath = args.msi_filepath
+    if not main_out_directory:
+        main_out_directory = args.output_directory
+    if not sevenz_path:
+        sevenz_path = args.sevenz_path
+
+    # If not provided, raise an error.
+    if not msi_filepath:
+        print_api("The path to the MSI file is not provided.", color="red")
+        sys.exit()
+    if not main_out_directory:
+        print_api("The main output directory is not provided.", color="red")
+    if not sevenz_path:
+        print_api(
+            "The path to the 7z executable is not provided. Assuming 7z is in the PATH environment variable.",
+            color="yellow")
+
+    if not sevenz_app_w.is_path_contains_7z_executable(sevenz_path):
+        print_api("The path to 7z does not contain 7z executable", color="red")
+        sys.exit()
+
+    if not os.path.isfile(sevenz_path):
+        print_api("The path to 7z executable doesn't exist.", color="red")
+        sys.exit()
+
+    if not sevenz_app_w.is_executable_a_7z(sevenz_path):
+        print_api("Provided 7z executable is not 7z.", color="red")
+        sys.exit()
+
+    # Create the main output directory.
+    os.makedirs(main_out_directory, exist_ok=True)
+
+    # Open the MSI database file.
+    db_handle = base.create_open_db_handle(msi_filepath)
+
+    embedded_files_directory = os.path.join(main_out_directory, EMBEDDED_FILES)
+
+    # Extract files using the MSI database handle.
+    tables.extract_table_contents_to_csv(db_handle, os.path.join(embedded_files_directory, TABLE_CONTENTS))
+    tables.extract_binary_table_entries(db_handle, os.path.join(embedded_files_directory, BINARY_FILES))
+    tables.extract_icon_table_entries(db_handle, os.path.join(embedded_files_directory, ICON_FILES))
+    tables.extract_issetupfiles_table_entries(db_handle, os.path.join(embedded_files_directory, ISSETUPFILES))
+    tables.extract_registry_changes(db_handle, os.path.join(embedded_files_directory, REGISTRY_CHANGES))
+
+    # Extract CAB files from the MSI file.
+    cab_files = tables.list_media_table_entries(db_handle)
+    print(f"CAB files found: {cab_files}")
+    extracted_cab_file_paths: list = tables.extract_cab_files_from_media(
+        db_handle, os.path.join(embedded_files_directory, CAB_FILES))
+
+    # Extract installation files from CAB files and rename them to their real names from DB.
+    cabs.extract_files_from_cab(
+        db_handle,
+        extracted_cab_file_paths[0],
+        os.path.join(main_out_directory, EXTRACTED_FILES),
+        sevenz_path=sevenz_path)
+
+    # Close the MSI database handle.
+    msi.MsiCloseHandle(db_handle)
+
+    # Extract OLE metadata from the MSI file.
+    olefilew.extract_ole_metadata(msi_filepath, os.path.join(embedded_files_directory, OLE_METADATA))