atomicshop 2.15.11__py3-none-any.whl → 3.10.5__py3-none-any.whl

atomicshop/wrappers/fibratusw/install.py

@@ -1,81 +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, exit_on_error=True, as_admin=True)
-
-    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/infrastructure.py

@@ -1,53 +0,0 @@
-from typing import Union
-
-from pymongo import MongoClient
-import pymongo.errors
-
-from ... import get_process_list, filesystem
-
-
-WHERE_TO_SEARCH_FOR_MONGODB_EXE: str = 'C:\\Program Files\\MongoDB\\Server\\'
-MONGODB_EXE_NAME: str = 'mongod.exe'
-MONGODB_DEFAULT_URI: str = 'mongodb://localhost:27017/'
-
-
-class MongoDBNoConnectionError(Exception):
-    pass
-
-
-def test_connection(
-        uri: str = MONGODB_DEFAULT_URI,
-        raise_exception: bool = False
-) -> bool:
-    try:
-        client = MongoClient(uri)
-        client.admin.command('ping')
-        return True
-    except pymongo.errors.ServerSelectionTimeoutError:
-        if raise_exception:
-            raise MongoDBNoConnectionError(f"Could not connect to the MongoDB server on: ")
-        return False
-
-
-def is_service_running() -> bool:
-    """
-    Check if the MongoDB service is running.
-    :return: bool, True if the MongoDB service is running, False otherwise.
-    """
-    current_processes: dict = (
-        get_process_list.GetProcessList(get_method='pywin32', connect_on_init=True).get_processes())
-
-    for pid, process_info in current_processes.items():
-        if MONGODB_EXE_NAME in process_info['name']:
-            return True
-
-    return False
-
-
-def is_installed() -> Union[str, None]:
-    """
-    Check if MongoDB is installed.
-    :return: string if MongoDB executable is found, None otherwise.
-    """
-
-    return filesystem.find_file(MONGODB_EXE_NAME, WHERE_TO_SEARCH_FOR_MONGODB_EXE)

atomicshop/wrappers/mongodbw/install_mongodb.py

@@ -1,190 +0,0 @@
-import os
-import requests
-from typing import Union
-import argparse
-import subprocess
-
-from ... import urls, web, permissions
-from ...print_api import print_api
-from .. import msiw
-from . import infrastructure
-
-
-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(
-        no_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 no_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.')
-    parser.add_argument(
-        '-nr', '--no-rc', action='store_true', help='Do not download release candidate versions.')
-    parser.add_argument(
-        '-m', '--major', type=int, help='Download the latest version of the specified major version.')
-    parser.add_argument(
-        '-c', '--compass', action='store_true', help='Install MongoDB Compass.')
-    parser.add_argument(
-        '-f', '--force', action='store_true', help='Force the installation even if MongoDB is already installed.')
-
-    return parser.parse_args()
-
-
-def download_install_latest_main(
-        no_rc_version: bool = False,
-        major_specific: int = None,
-        compass: bool = False,
-        force: bool = False
-):
-    """
-    Download and install the latest version of MongoDB Community Server.
-    :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:
-    """
-
-    args = parse_args()
-
-    # Set the args only if they were used.
-    if args.no_rc:
-        no_rc_version = args.no_rc
-    if args.major:
-        major_specific = args.major
-    if args.compass:
-        compass = args.compass
-    if args.force:
-        force = args.force
-
-    if not permissions.is_admin():
-        print_api("This function requires administrator privileges.", color='red')
-        return 1
-
-    if infrastructure.is_service_running():
-        print_api("MongoDB service is running - already installed.", color='blue')
-
-        if not force:
-            return 0
-    else:
-        print_api("MongoDB is service is not running.")
-
-        mongo_is_installed: Union[str, None] = infrastructure.is_installed()
-        if infrastructure.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(no_rc_version=no_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 = infrastructure.is_installed()
-    if not mongo_is_installed:
-        message += "MongoDB Executable not found.\n"
-
-    if not infrastructure.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

atomicshop/wrappers/msiw.py

@@ -1,149 +0,0 @@
-import subprocess
-import sys
-
-from ..print_api import print_api
-from .. import permissions
-from ..import get_process_list
-from .psutilw import processes
-
-
-ERROR_CODES = {
-    '1603': 'The App is already installed or Insufficient permissions',
-    '1619': 'This installation package could not be opened. Verify that the package exists and that you can '
-            'install it manually, also check the installation command line switches'
-}
-
-
-class MsiInstallationError(Exception):
-    pass
-
-
-def get_current_msiexec_processes(msi_file_path: str = None) -> dict:
-    """
-    Get the current msiexec processes.
-    :param msi_file_path: string, OPTIONAL path to the MSI file to check in the command line.
-    :return: list of dicts, each key represents a pid and its values are process name and cmdline.
-    """
-
-    current_processes: dict = (
-        get_process_list.GetProcessList(get_method='pywin32', connect_on_init=True).get_processes())
-
-    current_msiexec_dict: dict = {}
-    for pid, process_info in current_processes.items():
-        if 'msiexec.exe' in process_info['name']:
-            if msi_file_path:
-                if msi_file_path in process_info['cmdline']:
-                    current_msiexec_dict[pid] = process_info
-            else:
-                current_msiexec_dict[pid] = process_info
-
-    return current_msiexec_dict
-
-
-def wait_for_msiexec_processes_to_finish(msi_file_path: str):
-    """
-    Wait for the msiexec processes to finish.
-    :param msi_file_path: string, path to the MSI file.
-    :return:
-    """
-
-    current_msiexec: dict = get_current_msiexec_processes(msi_file_path)
-    current_pid = list(current_msiexec.keys())[0]
-
-    result_code = processes.wait_for_process(current_pid)
-    if result_code != 0:
-        raise Exception(f"MSI Installation failed. Return code: {result_code}")
-
-
-def install_msi(
-        msi_path,
-        silent_no_gui: bool = False,
-        silent_progress_bar: bool = False,
-        no_restart: bool = False,
-        terminate_required_processes: bool = False,
-        additional_args: str = None,
-        create_log_near_msi: bool = False,
-        log_file_path: str = None,
-        scan_log_for_errors: bool = False,
-        # as_admin=True,
-        print_kwargs: dict = None):
-    """
-    Install an MSI file silently.
-    :param msi_path: str, path to the MSI file.
-    :param silent_no_gui: bool, whether to run the installation silently, without showing GUI.
-    :param silent_progress_bar: bool, whether to show a progress bar during silent installation.
-    :param no_restart: bool, whether to restart the computer after installation.
-    :param terminate_required_processes: bool, whether to terminate processes that are required by the installation.
-    :param additional_args: str, additional arguments to pass to the msiexec command.
-    :param create_log_near_msi: bool, whether to create a log file near the MSI file.
-        If the msi file located in 'c:\\path\\to\\file.msi', the log file will be created in 'c:\\path\\to\\file.log'.
-        The log options that will be used: /l*v c:\\path\\to\\file.log
-    :param log_file_path: str, path to the log file. Even if 'create_log_near_msi' is False, you can specify a custom
-        path for the log file, and it will be created.
-        The log options that will be used: /l*v c:\\path\\to\\file.log
-    :param scan_log_for_errors: bool, whether to scan the log file for errors in case of failure.
-    # :param as_admin: bool, whether to run the installation as administrator.
-    :param print_kwargs: dict, print_api kwargs.
-    :return:
-    """
-
-    if not permissions.is_admin():
-        raise PermissionError("This function requires administrator privileges.")
-
-    if silent_progress_bar and silent_no_gui:
-        raise ValueError("silent_progress_bar and silent_no_gui cannot be both True.")
-
-    if create_log_near_msi and log_file_path:
-        raise ValueError("create_log_near_msi and log_file_path cannot be both set.")
-
-    if create_log_near_msi:
-        log_file_path = msi_path.replace('.msi', '.log')
-
-    if scan_log_for_errors and not log_file_path:
-        raise ValueError("[scan_log_for_errors] is set, but [log_file_path] or [create_log_near_msi] is not set.")
-
-    # Define the msiexec command
-    command = f'msiexec /i "{msi_path}"'
-
-    if silent_no_gui:
-        command = f"{command} /qn"
-    if silent_progress_bar:
-        command = f"{command} /qb"
-    if no_restart:
-        command = f"{command} /norestart"
-
-    if log_file_path:
-        command = f"{command} /l*v {log_file_path}"
-
-    if terminate_required_processes:
-        command = f"{command} REBOOT=ReallySuppress"
-
-    if additional_args:
-        if additional_args.startswith(' '):
-            additional_args = additional_args[1:]
-        command = f"{command} {additional_args}"
-
-    # if as_admin:
-    #     command = permissions.get_command_to_run_as_admin_windows(command)
-
-    # Run the command
-    result = subprocess.run(command, capture_output=True, text=True)
-
-    # Check the result
-    if result.returncode == 0:
-        print_api("MSI Installation completed.", color="green", **(print_kwargs or {}))
-    else:
-        message = (f"Installation failed. Return code: {result.returncode}\n{ERROR_CODES.get(str(result.returncode), '')}\n"
-                   f"MSI path: {msi_path}\nCommand: {command}\nOutput: {result.stdout}\nError: {result.stderr}")
-
-        if scan_log_for_errors:
-            with open(log_file_path, 'r', encoding='utf-16 le') as f:
-                log_content = f.read()
-            if 'error' in log_content.lower():
-                # Get the error text of the lines that contain 'error'.
-                error_lines = [line for line in log_content.split('\n') if 'error' in line.lower()]
-                for line in error_lines:
-                    message += f"\n{line}"
-
-        print_api(message, color="red", **(print_kwargs or {}))
-        raise MsiInstallationError("MSI Installation Failed.")

atomicshop/wrappers/nodejsw/install_nodejs.py

@@ -1,139 +0,0 @@
-import subprocess
-import requests
-
-from ...basics import booleans
-from .. import githubw, ubuntu_terminal
-from ...print_api import print_api
-
-
-def is_nodejs_installed():
-    """
-    The function will check if Node.js is installed.
-    :return: bool.
-    """
-
-    try:
-        # Run the command 'node -v'
-        result = subprocess.run(['node', '-v'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-
-        # Check if the command was successful
-        if result.returncode == 0:
-            message = f"Node.js installed. Version: {result.stdout.strip()}"
-            print_api(message, color='green')
-            return True
-        else:
-            print_api("Node.js is not installed.")
-            return False
-    except FileNotFoundError:
-        print_api("Node command not found. Node.js is not installed.")
-        return False
-
-
-def get_nodejs_latest_version_number(
-        by_github_api: bool = True,
-        _by_nodejs_website: bool = False,
-        get_major: bool = False
-) -> str:
-    """
-    The function will get the latest version number of Node.js.
-    :param by_github_api: bool, if True, the function will get the version number using the GitHub API.
-        Limitations: rate limits apply.
-    :param _by_nodejs_website: bool, if True, the function will get the version number using the Node.js website.
-        Limitations: the website structure can change and the json file is relatively large.
-        This is only for reference, it is not tested.
-    :param get_major: bool, if True, the function will return only the major version number string.
-    :return: str.
-    """
-
-    if by_github_api and _by_nodejs_website:
-        raise ValueError("Only one of the arguments can be True.")
-    elif not by_github_api and not _by_nodejs_website:
-        raise ValueError("At least one of the arguments must be True.")
-
-    latest_version = ''
-    if by_github_api:
-        github_wrapper = githubw.GitHubWrapper('nodejs', 'node')
-        latest_version = github_wrapper.get_the_latest_release_version_number()
-    elif _by_nodejs_website:
-        url = "https://nodejs.org/dist/index.json"
-        response = requests.get(url)
-        versions = response.json()
-        latest_version = versions[0]['version']  # Assuming the first one is the latest.
-
-    if get_major:
-        latest_version = latest_version.replace('v', '')
-        latest_version = latest_version.split('.')[0]
-
-    return latest_version
-
-
-def install_nodejs_ubuntu(
-        install_latest_version: bool = False,
-        install_lts: bool = True,
-        install_by_version_number: str = None,
-        force_install: bool = False
-):
-    """
-    The function will install Node.js on Ubuntu.
-
-    :param install_latest_version: bool, if True, the function will install the latest version of Node.js.
-    :param install_lts: bool, if True, the function will install the LTS version of Node.js.
-    :param install_by_version_number: str, the version number of Node.js to install.
-    :param force_install: bool, if True, the function will install Node.js even if it is already installed.
-
-    :return:
-    """
-
-    booleans.check_3_booleans_when_only_1_can_be_true(
-        (install_latest_version, 'install_latest_version'),
-        (install_lts, 'install_lts'),
-        (install_by_version_number, 'install_by_version_number')
-    )
-
-    # Check if Node.js is already installed.
-    if is_nodejs_installed():
-        if not force_install:
-            return
-
-    # NodeSource is listed as source under official Node.js GitHub repository:
-    # https://github.com/nodejs/node?tab=readme-ov-file#current-and-lts-releases
-    print_api("Adding NodeSource repository...")
-
-    # Fetch and execute the NodeSource repository setup script.
-    if install_latest_version:
-        install_by_version_number: str = get_nodejs_latest_version_number(get_major=True)
-
-    command: str = ''
-    if install_latest_version or install_by_version_number:
-        command = f"curl -fsSL https://deb.nodesource.com/setup_{install_by_version_number}.x | sudo -E bash -"
-    elif install_lts:
-        command = "curl -fsSL https://deb.nodesource.com/setup_current.x | sudo -E bash -"
-
-    _ = subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT)
-
-    ubuntu_terminal.update_system_packages()
-    ubuntu_terminal.install_packages(['nodejs'])
-
-    # Check if Node.js is installed.
-    is_nodejs_installed()
-
-
-def install_npm_package_ubuntu(package_name: str, sudo: bool = True):
-    """
-    The function will install a npm package on Ubuntu.
-    :param package_name: str, the name of the package to install.
-    :param sudo: bool, if True, the function will use sudo.
-        NPM commands require sudo to install global packages.
-    :return:
-    """
-
-    # Check if Node.js is installed.
-    if not is_nodejs_installed():
-        return
-
-    command = f"npm install -g {package_name}"
-
-    if sudo:
-        command = f"sudo {command}"
-
-    _ = subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT)

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)

atomicshop/wrappers/psutilw/networks.py

@@ -1,45 +0,0 @@
-from typing import Union
-import shlex
-
-import psutil
-
-
-def get_process_using_port(port: int) -> Union[dict, None]:
-    """
-    Function to find the process using the port.
-    :param port: Port number.
-    :return: dict['pid', 'name', 'cmdline'] or None.
-    """
-    for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
-        try:
-            connections = proc.connections(kind='inet')
-            for conn in connections:
-                if conn.laddr.port == port:
-                    cmdline = proc.info['cmdline']
-                    if not cmdline:
-                        cmdline = '<EMPTY: TRY RUNNING AS ADMIN>'
-                    else:
-                        cmdline = shlex.join(cmdline)
-                    return {
-                        'pid': proc.info['pid'],
-                        'name': proc.info['name'],
-                        'cmdline': cmdline
-                    }
-        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-            pass
-    return None
-
-
-def get_processes_using_port_list(ports: list) -> Union[dict, None]:
-    """
-    Function to find the process using the port.
-    :param ports: List of port numbers.
-    :return: dict[port: {'pid', 'name', 'cmdline'}] or None.
-    """
-    port_process_map = {}
-    for port in ports:
-        process_info = get_process_using_port(port)
-        if process_info:
-            port_process_map[port] = process_info
-
-    return port_process_map