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

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))

atomicshop/wrappers/ctyping/msi_windows_installer/tables.py

@@ -0,0 +1,419 @@
+import os
+import csv
+import ctypes
+from ctypes import wintypes
+
+from . import base
+from .base import msi
+
+
+def get_column_names(db_handle, table_name):
+    """Fetch column names for a specific table."""
+    column_names = []
+    query = f"SELECT `Name` FROM `_Columns` WHERE `Table`='{table_name}' ORDER BY `Number`"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        column_name = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+        if column_name:
+            column_names.append(column_name)
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+    return column_names
+
+
+def list_all_table_names(db_handle) -> list:
+    """List all tables in the MSI database."""
+    query = "SELECT `Name` FROM `_Tables`"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    tables: list = []
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+
+        # If record handle is empty then there is nothing more in the buffer, and we can stop the loop.
+        if not record_handle:
+            break
+
+        tables.append(base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw'))
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiViewClose(view_handle)
+
+    return tables
+
+
+def get_table_contents(db_handle, table_name):
+    """Fetch all contents of a specific table using ctypes."""
+    view_handle = base.create_open_execute_view_handle(db_handle, f"SELECT * FROM `{table_name}`")
+    contents = []
+
+    # Fetch column names
+    column_names = get_column_names(db_handle, table_name)
+    contents.append(column_names)
+
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        row = []
+        field_count = msi.MsiRecordGetFieldCount(record_handle)
+
+        for i in range(1, field_count + 1):
+            # Try to fetch as a string
+            buf_size = wintypes.DWORD(1024)
+            buf = ctypes.create_unicode_buffer(buf_size.value)
+            result = msi.MsiRecordGetStringW(record_handle, i, buf, ctypes.byref(buf_size))
+
+            if result == 0:
+                row.append(buf.value)
+            elif result == 234:  # ERROR_MORE_DATA
+                # Increase buffer size and try again
+                buf_size = wintypes.DWORD(buf_size.value + 1)
+                buf = ctypes.create_unicode_buffer(buf_size.value)
+                result = msi.MsiRecordGetStringW(record_handle, i, buf, ctypes.byref(buf_size))
+                if result == 0:
+                    row.append(buf.value)
+                else:
+                    row.append(None)
+            else:
+                # Try to fetch as an integer
+                int_value = ctypes.c_int()
+                result = msi.MsiRecordGetInteger(record_handle, i, ctypes.byref(int_value))
+                if result == 0:
+                    row.append(int_value.value)
+                else:
+                    # Try to fetch as a stream
+                    stream_size = wintypes.DWORD()
+                    result = msi.MsiRecordReadStream(record_handle, i, None, ctypes.byref(stream_size))
+                    if result == 0:
+                        stream_data = ctypes.create_string_buffer(stream_size.value)
+                        msi.MsiRecordReadStream(record_handle, i, stream_data, ctypes.byref(stream_size))
+                        row.append(stream_data.raw)
+                    else:
+                        row.append(None)
+
+        contents.append(row)
+        msi.MsiCloseHandle(record_handle)
+
+    msi.MsiCloseHandle(view_handle)
+    return contents
+
+
+def extract_table_contents_to_csv(db_handle, output_directory):
+    """Extracts all table contents to separate CSV files."""
+
+    os.makedirs(output_directory, exist_ok=True)
+
+    # Get all the table names.
+    table_names: list = list_all_table_names(db_handle)
+    # Get all the table contents by fetching each table.
+    table_contents = {table: get_table_contents(db_handle, table) for table in table_names}
+    print(f"Tables and their contents have been fetched.")
+
+    # Save each table to a separate CSV file
+    for table, contents in table_contents.items():
+        csv_file_path = os.path.join(output_directory, f"{table}.csv")
+        with open(csv_file_path, "w", newline='') as csv_file:
+            writer = csv.writer(csv_file)
+            writer.writerows(contents)
+        print(f"Table {table} contents saved to {csv_file_path}")
+
+    print("All table contents saved to separate CSV files in the 'tables' directory.")
+
+
+def extract_binary_table_entries(db_handle, output_directory: str):
+    os.makedirs(output_directory, exist_ok=True)
+
+    # Create and execute a view to query the Binary table
+    query = "SELECT Name, Data FROM Binary"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    while True:
+        # Fetch a record from the view
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        # Get the binary name
+        name = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+
+        # Get the size of the binary data
+        data_size = msi.MsiRecordDataSize(record_handle, 2)
+        if data_size == 0:
+            continue
+
+        # Read the binary data
+        binary_data = base.get_table_field_data_from_record(
+            record_handle, field_index=2, data_type='stream', buffer_size=data_size)
+
+        # Save the binary data to a file
+        output_filepath = os.path.join(output_directory, name)
+        print(f"Extracting binary file [{name}] to {output_filepath}")
+        with open(output_filepath, 'wb') as f:
+            f.write(binary_data)
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+
+def extract_icon_table_entries(db_handle, output_directory: str):
+    """Extracts icons from the Icon table in the specified MSI file."""
+    os.makedirs(output_directory, exist_ok=True)
+
+    query = "SELECT Name, Data FROM Icon"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    while True:
+        # Fetch a record from the view
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        # Read the Name (field 1) and Data (field 2) from the record
+        icon_filename = base.get_table_field_data_from_record(record_handle, 1, 'stringw')
+        icon_data = base.get_table_field_data_from_record(record_handle, 2, 'stream')
+
+        # Define the output file path
+        output_file_path = os.path.join(output_directory, f"{icon_filename}")
+
+        # Write the icon data to a file
+        with open(output_file_path, 'wb') as icon_file:
+            icon_file.write(icon_data)
+
+        print(f"Extracted icon: {output_file_path}")
+
+    # Close handles.
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+
+def extract_issetupfiles_table_entries(db_handle, output_directory: str):
+    """Extracts icons from the Icon table in the specified MSI file."""
+    os.makedirs(output_directory, exist_ok=True)
+
+    query = "SELECT FileName, Stream FROM ISSetupFile"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    while True:
+        # Fetch a record from the view
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        # Read the Name (field 1) and Data (field 2) from the record
+        file_name = base.get_table_field_data_from_record(record_handle, 1, 'stringw')
+        file_data = base.get_table_field_data_from_record(record_handle, 2, 'stream')
+
+        # Define the output file path
+        output_file_path = os.path.join(output_directory, f"{file_name}")
+
+        # Write the icon data to a file
+        with open(output_file_path, 'wb') as icon_file:
+            icon_file.write(file_data)
+
+        print(f"Extracted IsSetupFile: {output_file_path}")
+
+    # Close handles.
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+
+def extract_registry_changes(db_handle, output_directory: str):
+    """Extracts registry changes from the MSI file and writes them to a .reg file."""
+
+    os.makedirs(output_directory, exist_ok=True)
+    registry_file_path: str = os.path.join(output_directory, "registry_changes.reg")
+
+    # Create and execute a view for the Registry table
+    query = "SELECT `Root`, `Key`, `Name`, `Value` FROM `Registry`"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    with open(registry_file_path, 'w') as reg_file:
+        # Write the .reg file header
+        reg_file.write("Windows Registry Editor Version 5.00\n\n")
+
+        while True:
+            # Fetch a record from the view
+            record_handle = base.create_fetch_record_from_view_handle(view_handle)
+            if not record_handle:
+                break
+
+            # Read the Root (field 1), Key (field 2), Name (field 3), and Value (field 4) from the record
+            root = int(base.get_table_field_data_from_record(record_handle, 1, 'stringw'))
+            key = base.get_table_field_data_from_record(record_handle, 2, 'stringw')
+            name = base.get_table_field_data_from_record(record_handle, 3, 'stringw')
+            value = base.get_table_field_data_from_record(record_handle, 4, 'stringw')
+
+            # Determine the root key name
+            root_key = {
+                0: "HKEY_CLASSES_ROOT",
+                1: "HKEY_CURRENT_USER",
+                2: "HKEY_LOCAL_MACHINE",
+                3: "HKEY_USERS"
+            }.get(root, "UNKNOWN_ROOT")
+
+            # Format the registry entry
+            if name:
+                reg_entry = f'[{root_key}\\{key}]\n"{name}"="{value}"\n\n'
+            else:
+                reg_entry = f'[{root_key}\\{key}]\n@="{value}"\n\n'
+
+            # Write the registry entry to the .reg file
+            reg_file.write(reg_entry)
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+
+def list_media_table_entries(db_handle):
+    """List all CAB files from the Media table."""
+    query = "SELECT `Cabinet` FROM `Media`"
+    media_view = base.create_open_execute_view_handle(db_handle, query)
+
+    cab_files = []
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(media_view)
+        if not record_handle:
+            break
+
+        # The CAB file names are prefixed with #
+        cab_name = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+        cab_files.append(cab_name.strip("#"))
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(media_view)
+    return cab_files
+
+
+def extract_cab_files_from_media(db_handle, output_directory: str):
+    """Extract all CAB files from the list."""
+    os.makedirs(output_directory, exist_ok=True)
+
+    query = "SELECT `Cabinet` FROM `Media` WHERE `Cabinet` IS NOT NULL"
+    # Query to fetch CAB files from the Media table
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    cabinet_name_list: list = []
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        cabinet_name = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+        cabinet_name_list.append(cabinet_name)
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+    cab_file_paths: list = []
+    for cabinet_name in cabinet_name_list:
+        if cabinet_name.startswith("#"):
+            cabinet_name = cabinet_name[1:]  # Remove the leading #
+
+            cab_file_path = os.path.join(output_directory, cabinet_name)
+            with open(cab_file_path, 'wb') as f:
+                # Read the binary stream from the MSI package
+                stream_query = f"SELECT `Data` FROM `_Streams` WHERE `Name`='{cabinet_name}'"
+                stream_view = base.create_open_execute_view_handle(db_handle, stream_query)
+
+                while True:
+                    stream_record = base.create_fetch_record_from_view_handle(stream_view)
+                    if not stream_record:
+                        break
+
+                    data = base.get_table_field_data_from_record(stream_record, field_index=1, data_type='stream')
+
+                f.write(data)
+
+                msi.MsiCloseHandle(stream_record)
+                msi.MsiViewClose(stream_view)
+                msi.MsiCloseHandle(stream_view)
+
+            print(f"Extracted: {cabinet_name}")
+            cab_file_paths.append(cab_file_path)
+
+    print(f"CAB files extraction completed. Files are saved to {output_directory}")
+    return cab_file_paths
+
+
+def get_file_table_info(db_handle):
+    query = "SELECT `File`, `FileName`, `Component_` FROM `File`"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    file_info = {}
+
+    # Fetch the records
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        file_key = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+        # Handle cases with multiple file names
+        file_name = base.get_table_field_data_from_record(record_handle, field_index=2, data_type='stringw')
+        file_name = file_name.split('|')[-1]
+        component = base.get_table_field_data_from_record(record_handle, field_index=3, data_type='stringw')
+
+        file_info[file_key] = {'file_name': file_name, 'component': component}
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+    return file_info
+
+
+def get_component_table_info(db_handle):
+    component_info = {}
+
+    query = "SELECT `Component`, `Directory_` FROM `Component`"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    # Fetch the records
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        component_key = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+        directory = base.get_table_field_data_from_record(record_handle, field_index=2, data_type='stringw')
+
+        component_info[component_key] = {'directory': directory}
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+    return component_info
+
+
+def get_directory_table_info(db_handle):
+    directory_info = {}
+
+    # Open a view to the Directory table
+    query = "SELECT `Directory`, `Directory_Parent`, `DefaultDir` FROM `Directory`"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    # Fetch the records
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        directory_key = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+        parent_key = base.get_table_field_data_from_record(record_handle, field_index=2, data_type='stringw')
+
+        # Handle cases with multiple directory names with '|' character.
+        default_dir_buffer = base.get_table_field_data_from_record(record_handle, field_index=3, data_type='stringw')
+        default_dir = default_dir_buffer.split('|')[-1]
+
+        directory_info[directory_key] = {'parent': parent_key, 'default_dir': default_dir}
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+    return directory_info

atomicshop/wrappers/dockerw/install_docker.py

@@ -1,8 +1,10 @@
+import os
 import subprocess
 import getpass
 
 from ... import process, filesystem, permissions
 from ...print_api import print_api
+from .. import ubuntu_terminal
 
 
 def is_docker_installed():
@@ -59,14 +61,21 @@ def add_current_user_to_docker_group(print_kwargs: dict = None):
         return False
 
 
-def install_docker_ubuntu(rootless: bool = True, add_current_user_to_docker_group_bool: bool = False):
+def install_docker_ubuntu(
+        use_docker_installer: bool = True,
+        rootless: bool = False,
+        add_current_user_to_docker_group_bool: bool = False
+):
     """
     The function will install docker on ubuntu.
     :param rootless: bool, if True, the rootless installation will be performed.
         Meaning, you will be able to run the 'docker' command without sudo and you will not need to add the
         current user to the docker group.
+    :param use_docker_installer: bool, if True, the docker installer will be used.
+        If False, the docker will be installed using the apt package manager, custom repo and keyring.
     :param add_current_user_to_docker_group_bool: bool, if True, the current user will be added to the docker group.
-        So the user will be able to run the 'docker' command without sudo.
+        So the user will be able to run the 'docker' command without sudo. If you install docker in rootless mode
+        this is not needed.
 
     Usage in main.py (run with sudo):
         from atomicshop.wrappers.dockerw import install_docker
@@ -80,41 +89,66 @@ def install_docker_ubuntu(rootless: bool = True, add_current_user_to_docker_grou
             main()
     """
 
-    # Remove the existing keyrings, so we will not be asked to overwrite it if it exists.
-    docker_keyring_file_path: str = "/etc/apt/keyrings/docker.gpg"
-    filesystem.remove_file(docker_keyring_file_path)
-
-    script = f"""
-    # Step 1: Set up Docker's apt repository
-    sudo apt-get update
-    sudo apt-get install -y ca-certificates curl gnupg
-    sudo install -m 0755 -d /etc/apt/keyrings
-    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
-    sudo chmod a+r /etc/apt/keyrings/docker.gpg
-    
-    # Add the repository to Apt sources
-    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
-    sudo apt-get update
-    
-    # Step 2: Install the Docker packages
-    sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
-    
-    # Step 3: Verify the installation
-    # sudo docker run hello-world
-    
-    # Add Privileges to run docker without sudo. Add current user to Docker superuser group.
-    # sudo usermod -aG docker $USER
-    """
-
-    process.execute_script(script, shell=True)
+    if use_docker_installer:
+        # Use the docker installer script.
+        # The script will install docker and add the current user to the docker group.
+        # The script will also install docker-compose and docker-buildx.
+        process.execute_script('curl -fsSL https://get.docker.com -o get-docker.sh && sh get-docker.sh', shell=True)
+    else:
+        # Remove the existing keyrings, so we will not be asked to overwrite it if it exists.
+        docker_keyring_file_path: str = "/etc/apt/keyrings/docker.gpg"
+        filesystem.remove_file(docker_keyring_file_path)
+
+        script = f"""
+        # Step 1: Set up Docker's apt repository
+        sudo apt-get update
+        sudo apt-get install -y ca-certificates curl gnupg
+        sudo install -m 0755 -d /etc/apt/keyrings
+        curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
+        sudo chmod a+r /etc/apt/keyrings/docker.gpg
+        
+        # Add the repository to Apt sources
+        echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+        sudo apt-get update
+        
+        # Step 2: Install the Docker packages
+        sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
+        
+        # Step 3: Verify the installation
+        # sudo docker run hello-world
+        
+        # Add Privileges to run docker without sudo. Add current user to Docker superuser group.
+        # sudo usermod -aG docker $USER
+        """
+
+        process.execute_script(script, shell=True)
+
+    if rootless:
+        # Install uidmap package.
+        ubuntu_terminal.update_system_packages()
+        ubuntu_terminal.install_packages(['uidmap'])
+
+        # After 'get-docker.sh' execution, we will install docker in rootless mode.
+        subprocess.run(['dockerd-rootless-setuptool.sh', 'install'], shell=True)
+
+        # Start and enable the docker service in user mode.
+        ubuntu_terminal.start_enable_service_check_availability('docker.service', user_mode=True, sudo=False)
+
+        # Enable lingering so Docker runs when the user is not logged in
+        subprocess.run(['sudo', 'loginctl', 'enable-linger', os.getlogin()], shell=True)
+
+        # Add $HOME/bin to your PATH if it's not already there.
+        ubuntu_terminal.add_path_to_bashrc()
 
     if add_current_user_to_docker_group_bool:
         # Check if current user that executed the script is a sudo user. If not, use the current user.
         # Add the current user to the docker group.
         add_current_user_to_docker_group()
 
-    # Verify the installation.
-    result: list = process.execute_with_live_output('sudo docker run hello-world')
+        # Verify the installation.
+        result: list = process.execute_with_live_output('sudo docker run hello-world')
+    else:
+        result: list = process.execute_with_live_output('docker run hello-world')
 
     print_api('\n'.join(result))
 

atomicshop/wrappers/olefilew.py

@@ -0,0 +1,63 @@
+import os
+import datetime
+import json
+
+import olefile
+
+
+def convert_object_to_string(obj):
+    if isinstance(obj, bytes):
+        # MSI Database uses latin-1 encoding for strings, could be that other ole files too.
+        return obj.decode('latin-1')
+    elif isinstance(obj, datetime.datetime):
+        return obj.strftime('%Y-%m-%d-%H:%M:%S')
+    return obj
+
+
+def extract_ole_metadata(ole_file_path: str, output_directory: str):
+    """
+    Extract metadata from an OLE2 file.
+    :param ole_file_path:
+    :param output_directory:
+    :return:
+    """
+    os.makedirs(output_directory, exist_ok=True)
+    metadata_file_path = os.path.join(output_directory, "metadata.json")
+
+    # Check if the file is ole2 file.
+    if not olefile.isOleFile(ole_file_path):
+        message = f"The file {ole_file_path} is not an OLE2 file."
+        print(message)
+        with open(metadata_file_path, "w") as metadata_file:
+            metadata_file.write(message)
+        return
+
+    # Open the OLE2 file.
+    ole = olefile.OleFileIO(ole_file_path)
+
+    # Get the metadata of the OLE2 file.
+    metadata = ole.get_metadata()
+
+    meta_properties: dict = {
+        'SummaryInformation': {},
+        'DocumentSummaryInformation': {}
+    }
+    # Properties from SummaryInformation stream.
+    for prop in metadata.SUMMARY_ATTRIBS:
+        value = getattr(metadata, prop)
+        value = convert_object_to_string(value)
+        meta_properties['SummaryInformation'][prop] = value
+    # Properties from DocumentSummaryInformation stream.
+    for prop in metadata.DOCSUM_ATTRIBS:
+        value = getattr(metadata, prop)
+        value = convert_object_to_string(value)
+        meta_properties['DocumentSummaryInformation'][prop] = value
+
+    # Save the metadata to a file.
+    with open(metadata_file_path, "w") as metadata_file:
+        json.dump(meta_properties, metadata_file, indent=4)
+
+    print(f"Metadata of the OLE2 file saved to {metadata_file_path}")
+
+    # Close the OLE2 file.
+    ole.close()

atomicshop/wrappers/ubuntu_terminal.py

@@ -1,3 +1,4 @@
+import os
 import sys
 import subprocess
 import shutil
@@ -48,10 +49,25 @@ def upgrade_system_packages():
     subprocess.check_call(['sudo', 'apt-get', 'upgrade', '-y'])
 
 
-def is_service_running(service_name: str, return_false_on_error: bool = False) -> bool:
+def is_service_running(service_name: str, user_mode: bool = False, return_false_on_error: bool = False) -> bool:
+    """
+    Function checks if a service is running.
+    :param service_name: str, the service name.
+    :param user_mode: bool, if True, the service will be checked in user mode.
+    :param return_false_on_error: bool, if True, the function will return False if an error occurs.
+    :return:
+    """
+
+    command: list = ['systemctl']
+
+    if user_mode:
+        command.append('--user')
+
+    command.extend(['is-active', service_name])
+
     try:
         # Use subprocess to run 'systemctl is-active' and capture its output
-        status = subprocess.check_output(['systemctl', 'is-active', service_name], text=True).strip()
+        status = subprocess.check_output(command, text=True).strip()
     except subprocess.CalledProcessError as e:
         if return_false_on_error:
             # Handle error if systemctl command fails
@@ -66,22 +82,52 @@ def is_service_running(service_name: str, return_false_on_error: bool = False) -
         return False
 
 
-def enable_service(service_name: str):
+def enable_service(service_name: str, sudo: bool = True, user_mode: bool = False):
     """
     Function enables a service.
     :param service_name: str, the service name.
+    :param sudo: bool, if True, the command will be executed with sudo.
+    :param user_mode: bool, if True, the service will be enabled in user mode.
     :return:
     """
-    subprocess.check_call(['sudo', 'systemctl', 'enable', service_name])
 
+    command: list = []
+
+    if sudo:
+        command.append('sudo')
+
+    command.append('systemctl')
 
-def start_service(service_name: str):
+    if user_mode:
+        command.append('--user')
+
+    command.extend(['enable', service_name])
+
+    subprocess.check_call(command)
+
+
+def start_service(service_name: str, sudo: bool = True, user_mode: bool = False):
     """
     Function starts a service.
     :param service_name: str, the service name.
+    :param sudo: bool, if True, the command will be executed with sudo.
+    :param user_mode: bool, if True, the service will be started in user mode.
     :return:
     """
-    subprocess.check_call(['sudo', 'systemctl', 'start', service_name])
+
+    command: list = []
+
+    if sudo:
+        command.append('sudo')
+
+    command.append('systemctl')
+
+    if user_mode:
+        command.append('--user')
+
+    command.extend(['start', service_name])
+
+    subprocess.check_call(command)
 
 
 def start_enable_service_check_availability(
@@ -91,6 +137,8 @@ def start_enable_service_check_availability(
         start_service_bool: bool = True,
         enable_service_bool: bool = True,
         check_service_running: bool = True,
+        user_mode: bool = False,
+        sudo: bool = True,
         print_kwargs: dict = None
 ):
     """
@@ -103,6 +151,8 @@ def start_enable_service_check_availability(
     :param start_service_bool: bool, if True, the service will be started.
     :param enable_service_bool: bool, if True, the service will be enabled.
     :param check_service_running: bool, if True, the function will check if the service is running.
+    :param user_mode: bool, if True, the service will be started and enabled in user mode.
+    :param sudo: bool, if True, the command will be executed with sudo.
     :param print_kwargs: dict, the print arguments.
     :return:
     """
@@ -112,9 +162,9 @@ def start_enable_service_check_availability(
 
     # Start and enable the service.
     if start_service_bool:
-        start_service(service_name)
+        start_service(service_name, user_mode=user_mode, sudo=sudo)
     if enable_service_bool:
-        enable_service(service_name)
+        enable_service(service_name, user_mode=user_mode,sudo=sudo)
 
     if check_service_running:
         print_api(
@@ -122,10 +172,23 @@ def start_enable_service_check_availability(
             **(print_kwargs or {}))
         time.sleep(wait_time_seconds)
 
-        if not is_service_running(service_name):
+        if not is_service_running(service_name, user_mode=user_mode):
             print_api(
                 f"[{service_name}] service failed to start.", color='red', error_type=True, **(print_kwargs or {}))
             if exit_on_error:
                 sys.exit(1)
         else:
             print_api(f"[{service_name}] service is running.", color='green', **(print_kwargs or {}))
+
+
+def add_path_to_bashrc():
+    """Add $HOME/bin to the PATH in .bashrc if it's not already present."""
+    bashrc_path = os.path.expanduser("~/.bashrc")
+    new_path = 'export PATH=$PATH:$HOME/bin\n'
+    with open(bashrc_path, 'r+') as bashrc:
+        content = bashrc.read()
+        if "$HOME/bin" not in content:
+            bashrc.write(new_path)
+            print("Added $HOME/bin to .bashrc")
+        else:
+            print("$HOME/bin already in .bashrc")

{atomicshop-2.10.8.dist-info → atomicshop-2.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.10.8
+Version: 2.11.0
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License: MIT License
@@ -39,6 +39,7 @@ Requires-Dist: dnspython
 Requires-Dist: docker
 Requires-Dist: elasticsearch
 Requires-Dist: numpy
+Requires-Dist: olefile
 Requires-Dist: openpyxl
 Requires-Dist: pandas
 Requires-Dist: paramiko

{atomicshop-2.10.8.dist-info → atomicshop-2.11.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=jLebawbp1INbR4X9mVO70IY6_95wF8u3eJf77Id2Cis,123
+atomicshop/__init__.py,sha256=s2wz8eSBb6qWra33TBucyEy5wBD-UCjN1HUhZ99l0VE,123
 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
@@ -24,7 +24,7 @@ atomicshop/keyboard_press.py,sha256=1W5kRtOB75fulVx-uF2yarBhW0_IzdI1k73AnvXstk0,
 atomicshop/pbtkmultifile_argparse.py,sha256=aEk8nhvoQVu-xyfZosK3ma17CwIgOjzO1erXXdjwtS4,4574
 atomicshop/permissions.py,sha256=y63kcxU6GAmnVXqWhs_N29XorOD2xYWlK_CjZ1PpHgA,2897
 atomicshop/print_api.py,sha256=DhbCQd0MWZZ5GYEk4oTu1opRFC-b31g1VWZgTGewG2Y,11568
-atomicshop/process.py,sha256=SXaqG8pzNkHvppPhuhixEIXSaqbeDlTUFLaS5bYSp54,14176
+atomicshop/process.py,sha256=iP9H9Tr51o98REVjcFJ8D0BJUcjRpOVsD9yaEWoJ_h4,14686
 atomicshop/process_name_cmd.py,sha256=TNAK6kQZm5JKWzEW6QLqVHEG98ZLNDQiSS4YwDk8V8c,3830
 atomicshop/process_poller.py,sha256=WfmwCLALfTYOq8ri0vkPeqq8ruEyA_43DaN--CU2_XY,10854
 atomicshop/python_file_patcher.py,sha256=kd3rBWvTcosLEk-7TycNdfKW9fZbe161iVwmH4niUo0,5515
@@ -51,6 +51,7 @@ atomicshop/addons/a_setup_scripts/install_psycopg2_ubuntu.sh,sha256=lM7LkXQ2AxfF
 atomicshop/addons/a_setup_scripts/install_pywintrace_0.3.cmd,sha256=lEP_o6rWcBFUyup6_c-LTL3Q2LRMqryLuG3mJw080Zc,115
 atomicshop/addons/mains/install_docker_ubuntu_main_sudo.py,sha256=3VDGDO41Vubzf64DaBapLlFYX52dEdyPBNfolSsbGcM,161
 atomicshop/addons/mains/install_wsl_ubuntu_lts_admin.py,sha256=PrvZ4hMuadzj2GYKRZSwyNayJUuaSnCF9nV6ORqoPdo,123
+atomicshop/addons/mains/msi_unpacker.py,sha256=XAJdEqs-3s9JqIgHpGRL-HxLKpFMXdrlXmq2Is2Pyfk,164
 atomicshop/addons/mains/search_for_hyperlinks_in_docx.py,sha256=HkIdo_Sz9nPbbbJf1mwfwFkyI7vkvpH8qiIkuYopN4w,529
 atomicshop/addons/mains/FACT/factw_fact_extractor_docker_image_main_sudo.py,sha256=DDKX3Wp2SmzMCEtCIEOUbEKMob2ZQ7VEQGLEf9uYXrs,320
 atomicshop/addons/mains/FACT/update_extract.py,sha256=H3VsdhlA7xxK5lI_nyrWUdk8GNZXbEUVR_K9cJ4ECAw,506
@@ -68,6 +69,7 @@ atomicshop/archiver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 atomicshop/archiver/_search_in_zip.py,sha256=dd8qFSvIhcKmtnPj_uYNJFPmMwZp4tZys0kKgTw_ACw,8385
 atomicshop/archiver/archiver.py,sha256=BomnK7zT-nQXA1z0i2R2aTv8eu88wPx7tf2HtOdbmEc,1280
 atomicshop/archiver/search_in_archive.py,sha256=kui33oobL2F3VLgAE8L037rHR8Ud3HpXz_E0tbuiDD4,10473
+atomicshop/archiver/sevenz_app_w.py,sha256=TEOhlZPzKqQPStmyIq5E_yP98brj1t_GuoBgeLXA4dA,3019
 atomicshop/archiver/sevenzs.py,sha256=5i_C50-deC1Cz_GQdMGofV2jeMPbbGWAvih-QnA72cg,1370
 atomicshop/archiver/zips.py,sha256=k742K1bEDtc_4N44j_Waebi-uOkxxavqltvV6q-BLW4,14402
 atomicshop/basics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -145,17 +147,24 @@ atomicshop/wrappers/cryptographyw.py,sha256=H5NaHHDkr97QYhUrHFO9vY218u8k3N3Zgh6b
 atomicshop/wrappers/ffmpegw.py,sha256=wcq0ZnAe0yajBOuTKZCCaKI7CDBjkq7FAgdW5IsKcVE,6031
 atomicshop/wrappers/githubw.py,sha256=mQGtj6up1HIvjOD2t0bmOWjLooJLYvuIa7d7H-tknrw,9998
 atomicshop/wrappers/numpyw.py,sha256=sBV4gSKyr23kXTalqAb1oqttzE_2XxBooCui66jbAqc,1025
+atomicshop/wrappers/olefilew.py,sha256=biD5m58rogifCYmYhJBrAFb9O_Bn_spLek_9HofLeYE,2051
 atomicshop/wrappers/pipw.py,sha256=iq4pDhmrHqKbcRi3Y6_v2PQSdb4fqfAx79rsX7JEmXo,801
 atomicshop/wrappers/process_wrapper_pbtk.py,sha256=ycPmBRnv627RWks6N8OhxJQe8Gu3h3Vwj-4HswPOw0k,599
 atomicshop/wrappers/pyopensslw.py,sha256=OBWxA6EJ2vU_Qlf4M8m6ilcG3hyYB4yB0EsXUf7NhEU,6804
-atomicshop/wrappers/ubuntu_terminal.py,sha256=1CcTXASzxdFFFJTf3G1OtHcs8abbn_jgkPsY0OzEs1w,4132
+atomicshop/wrappers/ubuntu_terminal.py,sha256=Ykt3vSkvS2IddjRfZqwDbW98g4E1cServj6iUhg0n30,6121
 atomicshop/wrappers/wslw.py,sha256=AKphiHLSddL7ErevUowr3f9Y1AgGz_R3KZ3NssW07h8,6959
 atomicshop/wrappers/certauthw/certauth.py,sha256=hKedW0DOWlEigSNm8wu4SqHkCQsGJ1tJfH7s4nr3Bk0,12223
 atomicshop/wrappers/certauthw/certauthw.py,sha256=4WvhjANI7Kzqrr_nKmtA8Kf7B6rute_5wfP65gwQrjw,8082
+atomicshop/wrappers/ctyping/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/ctyping/process_winapi.py,sha256=QcXL-ETtlSSkoT8F7pYle97ubGWsjYp8cx8HxkVMgAc,2762
+atomicshop/wrappers/ctyping/msi_windows_installer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+atomicshop/wrappers/ctyping/msi_windows_installer/base.py,sha256=Uu9SlWLsQQ6mjE-ek-ptHcmgiI3Ruah9bdZus70EaVY,4884
+atomicshop/wrappers/ctyping/msi_windows_installer/cabs.py,sha256=htzwb2ROYI8yyc82xApStckPS2yCcoyaw32yC15KROs,3285
+atomicshop/wrappers/ctyping/msi_windows_installer/extract_msi_main.py,sha256=eyFAD1itG0UClPs92GFefIWTccRgRF55KVLKl1pugGw,5402
+atomicshop/wrappers/ctyping/msi_windows_installer/tables.py,sha256=ajiFiLXl1prg2kOhatfT8E2RKX7F8JjUJpwkVuKu1GY,16263
 atomicshop/wrappers/dockerw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/dockerw/dockerw.py,sha256=w8zSJr5C7cbvbuG09ORCpAe0BOcibqqL_Z2EKEBHYK4,6266
-atomicshop/wrappers/dockerw/install_docker.py,sha256=glX5UKReRc8rUrBQUKqIQb7HnLiG2QlPXxC-qemNpAc,5133
+atomicshop/wrappers/dockerw/install_docker.py,sha256=QNKLgm_UVpwN63D8v8k8FhOyEwA9XjHi0CT5f1FfEhA,6846
 atomicshop/wrappers/elasticsearchw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/elasticsearchw/config_basic.py,sha256=fDujtrjEjbWiYh_WQ3OcYp_8mXhXPYeKLy4wSPL5qM0,1177
 atomicshop/wrappers/elasticsearchw/elasticsearchw.py,sha256=7TqFdEFznO8NlligJhEKk1vm641ALpCYdaRl1uoXdzM,9768
@@ -233,8 +242,8 @@ atomicshop/wrappers/socketw/socket_server_tester.py,sha256=AhpurHJmP2kgzHaUbq5ey
 atomicshop/wrappers/socketw/socket_wrapper.py,sha256=aXBwlEIJhFT0-c4i8iNlFx2It9VpCEpsv--5Oqcpxao,11624
 atomicshop/wrappers/socketw/ssl_base.py,sha256=k4V3gwkbq10MvOH4btU4onLX2GNOsSfUAdcHmL1rpVE,2274
 atomicshop/wrappers/socketw/statistics_csv.py,sha256=t3dtDEfN47CfYVi0CW6Kc2QHTEeZVyYhc57IYYh5nmA,826
-atomicshop-2.10.8.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.10.8.dist-info/METADATA,sha256=35z6a8qlF_O0hPLHYCDfdrqRN_5nx52xrhoaQ0BbCqk,10423
-atomicshop-2.10.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-atomicshop-2.10.8.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.10.8.dist-info/RECORD,,
+atomicshop-2.11.0.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.11.0.dist-info/METADATA,sha256=4qiSE0G-IMCVID80QijXfSjtq7_eJvhsvkINwCxNGjA,10447
+atomicshop-2.11.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-2.11.0.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.11.0.dist-info/RECORD,,