atomicshop 3.3.8__py3-none-any.whl → 3.10.0__py3-none-any.whl

atomicshop/wrappers/ffmpegw.py

@@ -1,125 +0,0 @@
-import fnmatch
-import os
-import shlex
-
-from ..print_api import print_api
-from ..tempfiles import TempFile
-from .githubw import GitHubWrapper
-from ..process import execute_with_live_output
-from ..filesystem import create_directory
-
-
-class FFmpegWrapper:
-    def __init__(self, working_directory: str = str(), ffmpeg_exe_path: str = str()):
-        self.working_directory: str = working_directory
-        self.ffmpeg_exe_path: str = ffmpeg_exe_path
-        self.relative_path: str = 'bin'
-        self.ffmpeg_exe_name: str = 'ffmpeg.exe'
-
-        # Variables to download the latest release from GitHub in case execution fails.
-        self.git_user: str = 'GyanD'
-        self.git_repo: str = 'codexffmpeg'
-        self.git_latest_release_pattern: str = '*full_build.zip'
-
-        # ffmpeg Release directory name.
-        self.ffmpeg_release_directory_name: str = \
-            f"ffmpeg_{self.git_latest_release_pattern.replace('*', '').split('.')[0]}"
-        self.ffmpeg_release_directory_path: str = str()
-
-        # Execute functions.
-        self.build_ffmpeg_exe_and_directory_path()
-
-    def build_ffmpeg_exe_and_directory_path(self):
-        # If working directory was specified, but not the full path to exe.
-        if self.working_directory and not self.ffmpeg_exe_path:
-            self.ffmpeg_release_directory_path = self.working_directory + os.sep + self.ffmpeg_release_directory_name
-            self.ffmpeg_exe_path = \
-                self.ffmpeg_release_directory_path + os.sep + self.relative_path + os.sep + self.ffmpeg_exe_name
-        # If no working directory and no path to exe was specified.
-        elif not self.working_directory and not self.ffmpeg_exe_path:
-            # Use just 'ffmpeg.exe' as path to exe. Maybe it is already installed and is in environment PATH var.
-            self.ffmpeg_exe_path = self.ffmpeg_exe_name
-
-    def change_to_temp_directory(self):
-        temp_file = TempFile()
-        self.working_directory = temp_file.directory
-        self.ffmpeg_exe_path = str()
-        self.build_ffmpeg_exe_and_directory_path()
-
-    def download_ffmpeg_and_extract(self):
-        github_wrapper = GitHubWrapper(user_name=self.git_user, repo_name=self.git_repo)
-        github_wrapper.build_links_from_user_and_repo()
-        github_wrapper.download_and_extract_latest_release(
-            target_directory=self.ffmpeg_release_directory_path, string_pattern=self.git_latest_release_pattern,
-            archive_remove_first_directory=True)
-
-    def execute_ffmpeg(self, cmd_list: list):
-        continue_loop: bool = True
-        while continue_loop:
-            # If first entry contains 'ffmpeg.exe' and it is not 'self.ffmpeg_exe_path' already.
-            if self.ffmpeg_exe_name in cmd_list[0] and cmd_list[0] != self.ffmpeg_exe_path:
-                # We'll change it to the updated one.
-                cmd_list[0] = self.ffmpeg_exe_path
-            # If first entry doesn't contain 'ffmpeg.exe'.
-            elif self.ffmpeg_exe_name not in cmd_list[0]:
-                # We'll insert the current path into first entry.
-                cmd_list.insert(0, self.ffmpeg_exe_path)
-
-            output_strings: list = [
-                'Input',
-                'Output',
-                'video:'
-            ]
-
-            try:
-                print(f'FFmpeg processing: {shlex.join(cmd_list)}')
-                result_lines = execute_with_live_output(
-                    cmd=cmd_list, output_strings=output_strings, raise_exception=True, exit_on_error=False)
-            # If 'ffmpeg.exe' is non-existent.
-            except FileNotFoundError:
-                # Check if full path to 'ffmpeg.exe' is just 'ffmpeg.exe'.
-                if self.ffmpeg_exe_path == self.ffmpeg_exe_name:
-                    print_api('Will try temp folder...', raise_exception=False)
-                    # Change to temp folder and try executing again.
-                    self.change_to_temp_directory()
-                    continue
-
-                print_api('Trying to download...', raise_exception=False)
-                create_directory(self.ffmpeg_release_directory_path)
-                self.download_ffmpeg_and_extract()
-                continue
-
-            # === At this point python exceptions are finished. ==========================
-            # If 'Invalid argument' was returned by 'ffmpeg' in the last line.
-            if 'Invalid argument' in result_lines[-1]:
-                print_api(result_lines[-1], message_type_error=True, color="red", exit_on_error=True)
-
-            # === Successful execution section ==========================================
-            string_pattern = 'video:*audio:*subtitle*'
-            # if 'video:' in result_lines[-1] and 'audio:' in result_lines[-1] and 'subtitle:' in result_lines[-1]:
-            if fnmatch.fnmatch(result_lines[-1], string_pattern):
-                print_api(f'FFmpeg finished successfully.', color="green")
-
-            # Since exceptions are finished, we can stop the while loop.
-            continue_loop = False
-
-    def convert_file(self, source_file_path: str, dest_file_path: str, overwrite: bool = False) -> None:
-        """
-        The function converts source file to destination file. The source format is defined by the file extension
-        as well as destination file format defined by the destination file extension.
-
-        Example convert MP3 file to WAV:
-            convert_file(source_file_path=some_music.mp3, dest_file_path=converted_file.wav)
-
-        :param source_file_path: string, full file path to source file.
-        :param dest_file_path: string, full file path to destination file.
-        :param overwrite: boolean, set if destination file should be overwritten if it exists.
-        :return: None.
-        """
-
-        cmd_list = ['-i', source_file_path, dest_file_path]
-
-        if overwrite:
-            cmd_list.append('-y')
-
-        self.execute_ffmpeg(cmd_list)

atomicshop/wrappers/fibratusw/install.py

@@ -1,80 +0,0 @@
-import os.path
-import subprocess
-import time
-from typing import Literal
-
-from .. import githubw, msiw
-from ... import filesystem
-from ...print_api import print_api
-
-
-DEFAULT_INSTALLATION_EXE_PATH = r"C:\Program Files\Fibratus\Bin\fibratus.exe"
-WAIT_SECONDS_FOR_EXECUTABLE_TO_APPEAR_AFTER_INSTALLATION: float = 10
-
-
-def install_fibratus(
-        installation_file_download_directory: str = None,
-        place_to_download_file: Literal['working', 'temp', 'script'] = 'temp',
-        remove_file_after_installation: bool = False
-):
-    """
-    Download latest release from GitHub and install Fibratus.
-    :param installation_file_download_directory: Directory to download the installation file. If None, the download
-        directory will be automatically determined, by the 'place_to_download_file' parameter.
-    :param place_to_download_file: Where to download the installation file.
-        'working' is the working directory of the script.
-        'temp' is the temporary directory.
-        'script' is the directory of the script.
-    :param remove_file_after_installation: Whether to remove the installation file after installation.
-    :return:
-    """
-
-    if not installation_file_download_directory:
-        installation_file_download_directory = filesystem.get_download_directory(
-            place=place_to_download_file, script_path=__file__)
-
-    github_wrapper = githubw.GitHubWrapper(user_name='rabbitstack', repo_name='fibratus')
-    fibratus_setup_file_path: str = github_wrapper.download_latest_release(
-        target_directory=installation_file_download_directory,
-        string_pattern='*fibratus-*-amd64.msi',
-        exclude_string='slim')
-
-    # Install the MSI file
-    msiw.install_msi(msi_path=fibratus_setup_file_path)
-
-    count = 0
-    while count != WAIT_SECONDS_FOR_EXECUTABLE_TO_APPEAR_AFTER_INSTALLATION:
-        if os.path.isfile(DEFAULT_INSTALLATION_EXE_PATH):
-            break
-        count += 1
-        time.sleep(1)
-
-    if count == WAIT_SECONDS_FOR_EXECUTABLE_TO_APPEAR_AFTER_INSTALLATION:
-        message = \
-            (f"Fibratus installation failed. The executable was not found after "
-             f"{str(WAIT_SECONDS_FOR_EXECUTABLE_TO_APPEAR_AFTER_INSTALLATION)} seconds.\n"
-             f"{DEFAULT_INSTALLATION_EXE_PATH}")
-        print_api(message, color="red")
-
-    result = None
-    # Check if the installation was successful
-    try:
-        result = subprocess.run([DEFAULT_INSTALLATION_EXE_PATH], capture_output=True, text=True)
-    except FileNotFoundError:
-        print_api("Fibratus executable not found.", color="red")
-
-    if result:
-        if result.returncode == 0:
-            print_api("Fibratus installed successfully. Please restart.", color="green")
-        else:
-            print_api("Fibratus installation failed.", color="red")
-            print_api(result.stderr)
-            raise Exception("Fibratus installation failed.")
-    else:
-        print_api("Fibratus executable not found.", color="red")
-
-    # Wait for the installation to finish before removing the file.
-    time.sleep(5)
-
-    if remove_file_after_installation:
-        filesystem.remove_file(fibratus_setup_file_path)

atomicshop/wrappers/mongodbw/install_mongodb_ubuntu.py

@@ -1,100 +0,0 @@
-import subprocess
-import sys
-import os
-
-
-from ... import print_api, web
-from .. import ubuntu_terminal
-from ...permissions import ubuntu_permissions
-
-
-COMPASS_INSTALLATION_SCRIPT_URL: str = \
-    'https://raw.githubusercontent.com/mongodb/mongo/master/src/mongo/installer/compass/install_compass'
-
-
-def run_command(command):
-    """Run a system command and exit if the command fails."""
-    try:
-        subprocess.run(command, check=True, shell=True)
-    except subprocess.CalledProcessError as e:
-        print_api.print_api(f"Error: {e}", color='red')
-        sys.exit(1)
-
-
-def install_mongodb(version):
-    """Install the specified major version of MongoDB on Ubuntu."""
-
-    if not version.endswith(".0"):
-        version = f"{version}.0"
-
-    print_api.print_api(f"Installing MongoDB {version} on Ubuntu...")
-    print_api.print_api(f"Installing Prerequisites...")
-    ubuntu_terminal.update_system_packages()
-    ubuntu_terminal.install_packages(["wget", "curl", "gnupg"])
-
-    # Step 1: Import the MongoDB public GPG key
-    print_api.print_api("Step 1: Importing the MongoDB public GPG key...")
-    run_command(f"curl -fsSL https://pgp.mongodb.com/server-{version}.asc | "
-                f"sudo gpg --dearmor --yes -o /usr/share/keyrings/mongodb-server-{version}.gpg")
-
-    # Step 2: Create the MongoDB list file for APT
-    print_api.print_api("Step 2: Creating MongoDB APT list file...")
-    distro_version = subprocess.check_output("lsb_release -sc", shell=True).decode('utf-8').strip()
-    run_command(
-        f"echo 'deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-{version}.gpg ] "
-        f"https://repo.mongodb.org/apt/ubuntu {distro_version}/mongodb-org/{version} multiverse' | "
-        f"sudo tee /etc/apt/sources.list.d/mongodb-org-{version}.list")
-
-    # Step 3: Update the APT package index
-    print_api.print_api("Step 3: Updating the APT package index...")
-    ubuntu_terminal.update_system_packages()
-
-    # Step 4: Install the latest version of MongoDB for the specified major version
-    print_api.print_api(f"Step 4: Installing MongoDB version {version}...")
-    ubuntu_terminal.install_packages(["mongodb-org"])
-
-    # Step 5: Start MongoDB service and enable it on startup
-    print_api.print_api("Step 5: Starting MongoDB service and enabling it on startup...")
-    ubuntu_terminal.start_enable_service_check_availability("mongod")
-
-    print_api.print_api(f"MongoDB {version} installation complete!", color='green')
-
-
-def install_main(
-        compass: bool = False,
-):
-    """
-    Install the latest minor version of MongoDB Community Server on Ubuntu by providing the major version.
-    :param compass: bool, if True, MongoDB Compass will be installed.
-    :return:
-    """
-    # Ensure the user provides a MongoDB major version as an argument.
-    if len(sys.argv) != 2:
-        message: str = ("Usage: python install_mongodb.py <mongo_major_version>\n"
-                        "Example: python install_mongodb.py 8")
-        print_api.print_api(message, color='red')
-        return 1
-
-    mongo_version = sys.argv[1]
-
-    # Call the 'install' function with the major version.
-    install_mongodb(mongo_version)
-
-    if not compass:
-        return 0
-
-    # It doesn't matter what you do with the MSI it will not install Compass, only if you run it manually.
-    # So we will use installation script from their GitHub.
-    print_api.print_api("Downloading MongoDB Compass installation script...")
-    compass_script_path: str = web.download(COMPASS_INSTALLATION_SCRIPT_URL)
-
-    print_api.print_api("Installing MongoDB Compass from script...")
-    ubuntu_permissions.set_executable(compass_script_path)
-    run_command(f'sudo -E python3 {compass_script_path}')
-
-    # Clean up the installer file
-    if os.path.exists(compass_script_path):
-        os.remove(compass_script_path)
-        print_api.print_api("Cleaned up the Compass installer file.")
-
-    return 0

atomicshop/wrappers/mongodbw/install_mongodb_win.py

@@ -1,244 +0,0 @@
-import os
-import requests
-from typing import Union
-import argparse
-import subprocess
-
-from ... import urls, web
-from ...permissions import permissions
-from ...print_api import print_api
-from .. import msiw
-from . import mongo_infra
-
-
-MONGODB_DOWNLOAD_PAGE_URL: str = 'https://www.mongodb.com/try/download/community'
-COMPASS_INSTALLATION_SCRIPT_URL: str = \
-    'https://raw.githubusercontent.com/mongodb/mongo/master/src/mongo/installer/compass/Install-Compass.ps1'
-
-
-class MongoDBWebPageNoSuccessCodeError(Exception):
-    pass
-
-
-class MongoDBNoDownloadLinksError(Exception):
-    pass
-
-
-class MongoDBNoDownloadLinkForWindowsError(Exception):
-    pass
-
-
-class MongoDBInstallationError(Exception):
-    pass
-
-
-def get_latest_mongodb_download_url(
-        rc_version: bool = True,
-        major_specific: int = None
-):
-    response = requests.get(MONGODB_DOWNLOAD_PAGE_URL)
-
-    if response.status_code != 200:
-        raise MongoDBWebPageNoSuccessCodeError("Failed to load the download page.")
-
-    urls_in_page: list = urls.find_urls_in_text(response.text)
-    if not urls_in_page:
-        raise MongoDBNoDownloadLinksError("Could not find the download link for MongoDB Community Server.")
-
-    windows_urls: list = []
-    for url in urls_in_page:
-        if 'windows' in url and 'x86_64' in url and url.endswith('.msi'):
-            if not rc_version and '-rc' in url:
-                continue
-            windows_urls.append(url)
-
-    if major_specific:
-        for url in windows_urls:
-            if f'-{major_specific}.' in url:
-                windows_urls = [url]
-                break
-
-    if not windows_urls:
-        raise MongoDBNoDownloadLinkForWindowsError(
-            "Could not find the download link for MongoDB Community Server for Windows x86_64.")
-
-    # Return the latest URL only.
-    return windows_urls[0]
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='Install MongoDB Community Server.')
-    # Mutually exclusive group for 'ir' and 'er'
-    group = parser.add_mutually_exclusive_group()
-    group.add_argument(
-        '-er', '--exclude-rc',
-        action='store_true',
-        help='Install latest version, but exclude release candidate versions.'
-    )
-    group.add_argument(
-        '-ir', '--include-rc',
-        action='store_true',
-        help='Install the latest version of MongoDB including release candidates.'
-    )
-
-    # Optional arguments
-    parser.add_argument(
-        '-c', '--compass',
-        action='store_true',
-        help='Install MongoDB Compass.'
-    )
-    parser.add_argument(
-        '-m', '--major',
-        type=int,
-        help='Download the latest version of the specified major version.'
-    )
-    parser.add_argument(
-        '-f', '--force',
-        action='store_true',
-        help='Force the installation even if MongoDB is already installed.'
-    )
-
-    args = parser.parse_args()
-
-    # Validation logic: At least one of '-nr', '-ir', or '-c' must be provided
-    if not (args.no_rc or args.include_rc or args.compass):
-        parser.error("At least one of '-nr', '-ir', or '-c' must be specified.")
-
-    return args
-
-
-def download_install_process(
-        rc_version: bool = False,
-        no_rc_version: bool = True,
-        major_specific: int = None,
-        compass: bool = False,
-        force: bool = False
-) -> int:
-    """
-    Download and install the latest version of MongoDB Community Server.
-
-    :param rc_version: bool, if True, the latest RC version will be downloaded.
-    :param no_rc_version: bool, if True, the latest non-RC version will be downloaded.
-    :param major_specific: int, if set, the latest version of the specified major version will be downloaded.
-    :param compass: bool, if True, MongoDB Compass will be installed.
-    :param force: bool, if True, MongoDB will be installed even if it is already installed.
-    :return: int, 0 if successful, 1 if failed.
-    """
-
-    if not permissions.is_admin():
-        print_api("This function requires administrator privileges.", color='red')
-        return 1
-
-    if rc_version and no_rc_version:
-        print_api("Both 'rc_version' and 'no_rc_version' cannot be True at the same time.", color='red')
-        return 1
-
-    if not (rc_version or no_rc_version) and not compass:
-        print_api("At least one of 'rc_version', 'no_rc_version', or 'compass' must be True.", color='red')
-        return 1
-
-    # If we need to install mongo db.
-    if rc_version or no_rc_version:
-        if rc_version:
-            download_rc_version: bool = True
-        elif no_rc_version:
-            download_rc_version: bool = False
-        else:
-            raise ValueError("Invalid value for 'rc_version' and 'no_rc_version'.")
-
-        if mongo_infra.is_service_running():
-            print_api("MongoDB service is running - already installed. Use [-f] to reinstall.", color='blue')
-
-            if not force:
-                return 0
-        else:
-            print_api("MongoDB is service is not running.")
-
-            mongo_is_installed: Union[str, None] = mongo_infra.is_installed()
-            if mongo_infra.is_installed():
-                message = f"MongoDB is installed in: {mongo_is_installed}\n" \
-                          f"The service is not running. Fix the service or use the 'force' parameter to reinstall."
-                print_api(message, color='yellow')
-
-                if not force:
-                    return 0
-
-        print_api("Fetching the latest MongoDB download URL...")
-        mongo_installer_url = get_latest_mongodb_download_url(rc_version=download_rc_version, major_specific=major_specific)
-
-        print_api(f"Downloading MongoDB installer from: {mongo_installer_url}")
-        installer_file_path: str = web.download(mongo_installer_url)
-
-        print_api("Installing MongoDB...")
-        try:
-            msiw.install_msi(
-                installer_file_path,
-                silent_no_gui=True,
-                no_restart=True,
-                terminate_required_processes=True,
-                create_log_near_msi=True,
-                scan_log_for_errors=True,
-                additional_args='ADDLOCAL="ServerService"'
-            )
-        except msiw.MsiInstallationError as e:
-            print_api(f'{e} Exiting...', color='red')
-            return 1
-
-        # Check if MongoDB is installed.
-        message: str = ''
-        mongo_is_installed = mongo_infra.is_installed()
-        if not mongo_is_installed:
-            message += "MongoDB Executable not found.\n"
-
-        if not mongo_infra.is_service_running():
-            message += "MongoDB service is not running.\n"
-
-        if message:
-            message += f"MSI Path: {installer_file_path}"
-            print_api(message, color='red')
-            return 1
-        else:
-            success_message: str = f"MongoDB installed successfully to: {mongo_is_installed}\n" \
-                                   f"Service is running."
-            print_api(success_message, color='green')
-
-        # Clean up the installer file
-        if os.path.exists(installer_file_path):
-            os.remove(installer_file_path)
-            print_api("Cleaned up the installer file.")
-
-    if not compass:
-        return 0
-
-    # It doesn't matter what you do with the MSI it will not install Compass, only if you run it manually.
-    # So we will use installation script from their GitHub.
-    print_api("Downloading MongoDB Compass installation script...")
-    compass_script_path: str = web.download(COMPASS_INSTALLATION_SCRIPT_URL)
-
-    print_api("Installing MongoDB Compass from script...")
-    subprocess.run(["powershell", "-ExecutionPolicy", "Bypass", "-File", compass_script_path])
-
-    # Clean up the installer file
-    if os.path.exists(compass_script_path):
-        os.remove(compass_script_path)
-        print_api("Cleaned up the Compass installer file.")
-
-    return 0
-
-
-def download_install_latest_main() -> int:
-    """
-    Download and install the latest version of MongoDB Community Server.
-
-    :return: int, 0 if successful, 1 if failed.
-    """
-
-    args = parse_args()
-
-    return download_install_process(
-        rc_version=args.include_rc,
-        no_rc_version=args.exclude_rc,
-        major_specific=args.major,
-        compass=args.compass,
-        force=args.force
-    )

atomicshop/wrappers/process_wrapper_pbtk.py

@@ -1,16 +0,0 @@
-from atomicshop.process import execute_with_live_output
-
-
-def execute_pbtk(pbtk_path: str, file_path: str, target_directory: str) -> None:
-    """
-    The function receives file path and target filesystem directory to extract the files.
-
-    :param pbtk_path: full path to pbtk file.
-    :param file_path: full path to binary file.
-    :param target_directory: The directory on the filesystem to extract files.
-    """
-
-    cmd: str = f'python "{pbtk_path}" "{file_path}" "{target_directory}"'
-    print(f'Scanning: {file_path}')
-
-    output_list = execute_with_live_output(cmd=cmd)