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

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/socketw/base.py

@@ -1,59 +0,0 @@
-import socket
-
-
-def get_local_network_interfaces_ip_address(family_type: str = None, ip_only: bool = False) -> list:
-    """
-    Return list of IP addresses of local network interfaces.
-
-    :param family_type: string, available options:
-        None: default, returns both ipv4 and ipv6 addresses.
-        "ipv4": returns only ipv4 addresses.
-        "ipv6": returns only ipv6 addresses.
-    :param ip_only: bool, if True, returns only IP addresses, if False, returns tuples with all objects.
-    :return: list.
-    """
-    family: int = 0
-    if not family_type:
-        family = 0
-    elif family_type == "ipv4":
-        family = socket.AF_INET
-    elif family_type == "ipv6":
-        family = socket.AF_INET6
-
-    network_interfaces_tuples = list(socket.getaddrinfo(socket.gethostname(), None, family=family))
-
-    if not ip_only:
-        return network_interfaces_tuples
-    else:
-        return [i[4][0] for i in network_interfaces_tuples]
-
-
-def get_destination_address_from_socket(socket_object):
-    """
-    Return destination IP and port.
-
-    :param socket_object:
-    :return:
-    """
-    # return ip_address, port
-    return socket_object.getsockname()[0], socket_object.getsockname()[1]
-
-
-def get_source_address_from_socket(socket_object):
-    """
-    Return source IP and port.
-
-    :param socket_object:
-    :return:
-    """
-    # return ip_address, port
-    return socket_object.getpeername()[0], socket_object.getpeername()[1]
-
-
-def get_source_destination(socket_object):
-    return get_source_address_from_socket(socket_object), get_destination_address_from_socket(socket_object)
-
-
-def set_socket_timeout(socket_object, seconds: int = 1):
-    # Setting timeout on the socket before "accept()" drastically slows down connections.
-    socket_object.settimeout(seconds)

atomicshop/wrappers/socketw/get_process.py

@@ -1,107 +0,0 @@
-# Needed to redirect output from console to logger on LOCALHOST process command line harvesting.
-import io
-from contextlib import redirect_stdout
-
-from . import base
-from ...ssh_remote import SSHRemote
-from ...print_api import print_api
-
-import psutil
-
-
-def get_process_name(client_socket, config: dict, ssh_script_processor, print_kwargs: dict = None):
-    # Get client ip and the source port.
-    client_ip, source_port = base.get_source_address_from_socket(client_socket)
-
-    # Put source port variable inside the string script.
-    updated_script_string = ssh_script_processor.put_variable_into_script_string(source_port, print_kwargs=print_kwargs)
-
-    process_name = get_process_commandline(
-        client_ip=client_ip,
-        username=config['ssh']['user'],
-        password=config['ssh']['pass'],
-        script_string=updated_script_string,
-        print_kwargs=print_kwargs)
-
-    return process_name
-
-
-def get_process_commandline(
-        client_ip: str, username: str, password: str, script_string: str, print_kwargs: dict = None):
-    execution_output = None
-    execution_error = None
-
-    # Checking if we're on localhost. If not, we'll execute SSH connection to get calling process name.
-    if client_ip != "127.0.0.1":
-        # Tried using paramiko SSH concurrently within threads, but with bigger loads it just breaks.
-        # So, better using it separately for each thread.
-
-        print_api(f"Initializing SSH connection to [{client_ip}]", **print_kwargs)
-        # Initializing SSHRemote class.
-        current_ssh_client = SSHRemote(ip_address=client_ip, username=username, password=password)
-
-        execution_output, execution_error = current_ssh_client.connect_get_client_commandline(script_string)
-    # Else, if we're on localhost, then execute the script directly without SSH.
-    else:
-        print_api(f"Executing LOCALHOST command to get the calling process.", **print_kwargs)
-        # Getting the redirection from console print, since that what the 'script_string' does.
-        with io.StringIO() as buffer, redirect_stdout(buffer):
-            # Executing the script with print to console.
-            try:
-                exec(script_string)
-            except ModuleNotFoundError as function_exception_object:
-                execution_error = f"Module not installed: {function_exception_object}"
-                print_api(
-                    execution_error, error_type=True, logger_method="error", traceback_string=True, oneline=True,
-                    **print_kwargs)
-                pass
-            except psutil.AccessDenied:
-                execution_error = f"Access Denied for 'psutil' to read system process command line. " \
-                                  f"Run script with Admin Rights."
-                print_api(
-                    execution_error, error_type=True, logger_method="error", traceback_string=True, oneline=True,
-                    **print_kwargs)
-                pass
-            except Exception:
-                execution_error = "There was undocumented exception in localhost script execution."
-                print_api(
-                    execution_error, error_type=True, logger_method="error", traceback_string=True, oneline=True,
-                    **print_kwargs)
-                pass
-
-            if not execution_error:
-                # Reading the buffer.
-                execution_output = buffer.getvalue()
-
-    # This section is generic for both remote SSH and localhost executions of the script.
-    process_name = get_commandline_and_error(execution_output, execution_error, print_kwargs=print_kwargs)
-
-    return process_name
-
-
-def get_commandline_and_error(execution_output, execution_error, print_kwargs: dict = None):
-    # If there was known error on localhost / known error on remote or any kind of error on remote, it was
-    # already logged, so we'll just put the error into 'process_name'.
-    if execution_error:
-        process_name = execution_error
-        print_api(
-            f"Error During Command Execution: {process_name}", error_type=True, logger_method='error', **print_kwargs)
-    # If there wasn't any error of above types, then we can put the output from either local or remote script
-    # execution into 'process_name' and log it / output to console.
-    else:
-        # If the output that was returned is not empty.
-        if execution_output:
-            # Replacing '\r\n' escape lines with string, so that the line will not be escaped in logs.
-            if '\r\n' in execution_output:
-                execution_output = execution_output.replace('\r\n', '')
-            elif '\n' in execution_output:
-                execution_output = execution_output.replace('\n', '')
-
-            process_name = execution_output
-            print_api(f"Client Process Command Line: {process_name}", **print_kwargs)
-        # Else if the script output came back empty.
-        else:
-            process_name = "Client Process Command Line came back empty after script execution."
-            print_api(process_name, error_type=True, logger_method='error', **print_kwargs)
-
-    return process_name

atomicshop/wrappers/wslw.py

@@ -1,191 +0,0 @@
-import sys
-from pathlib import Path
-
-from ..import process, permissions, virtualization
-from ..print_api import print_api
-
-
-def is_installed():
-    # Command to check the status of the WSL feature
-    command = "Get-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux"
-
-    # Check if WSL is enabled
-    if "Enabled" in process.run_powershell_command(command):
-        return True
-    else:
-        return False
-
-
-def get_installed_distros() -> list:
-    """
-    Get a list of installed WSL distros.
-    :return: list, list of installed WSL distros.
-    """
-    return process.execute_with_live_output("wsl --list --quiet")
-
-
-def get_available_distros_to_install() -> list:
-    """
-    Get a list of available WSL distros to install.
-    :return: list, list of available WSL distros to install.
-    """
-    return process.execute_with_live_output("wsl --list --online")
-
-
-def is_ubuntu_installed(version: str = "22.04") -> bool:
-    """
-    Check if specific version of Ubuntu is installed on WSL.
-    :param version: string, Ubuntu version to check for. Default is 22.04.
-    :return: bool, True if Ubuntu is installed, False otherwise.
-    """
-
-    if not version:
-        version = str()
-
-    installed_distros_list = get_installed_distros()
-
-    if f'Ubuntu-{version}' in installed_distros_list:
-        return True
-    elif 'Ubuntu' in installed_distros_list:
-        # Command to get Ubuntu version
-        command = f"wsl -d Ubuntu lsb_release -a"
-
-        # Execute the command
-        result = process.execute_with_live_output(command)
-
-        is_version_installed: bool = False
-        # Parse the output for the version number
-        for line in result:
-            if "Release" in line and version in line:
-                is_version_installed = True
-                break
-
-        return is_version_installed
-    else:
-        return False
-
-
-def install_wsl_manual(
-        directory_path: str, enable_virtual_machine_platform: bool = True, set_default_version_2: bool = True):
-    # noinspection GrazieInspection
-    """
-        Install WSL on Windows 10.
-        :param directory_path: string, directory path to save Ubuntu package.
-        :param enable_virtual_machine_platform: bool, True to enable Virtual Machine Platform feature.
-        :param set_default_version_2: bool, True to set WSL version 2 as default.
-
-        Main.py example:
-            import sys
-            from atomicshop.wrappers import wslw
-
-
-            def main():
-                if len(sys.argv) < 2:
-                    print("Usage: python main.py <directory_path_to_save_Ubuntu_package>")
-                    sys.exit(1)
-
-                wslw.install_wsl(directory_path=sys.argv[1])
-
-
-            if __name__ == '__main__':
-                main()
-        """
-
-    # Check for admin privileges
-    if not permissions.is_admin():
-        sys.exit("Script must be run as administrator")
-
-    # Check if WSL is already installed
-    if is_installed():
-        print_api("WSL is already installed", color='green')
-    else:
-        # Enable WSL
-        print_api("Enabling Windows Subsystem for Linux...")
-        process.run_powershell_command(
-            "Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux -NoRestart")
-
-        # # Check if the system needs a reboot
-        # if "RestartNeeded : True" in process.run_powershell_command(
-        #         "Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux"):
-        #     print_api("Please restart your computer to complete the installation of WSL and rerun the script.")
-        #     sys.exit(0)
-
-    # Enable Virtual Machine Platform is needed for WSL 2.
-    if enable_virtual_machine_platform:
-        # Check if Hyper-V is enabled
-        if "Enabled" in process.run_powershell_command(
-                "Get-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V"):
-            print_api("Hyper-V is enabled")
-        else:
-            # Command to enable Virtual Machine Platform
-            command = "Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V -All -NoRestart"
-
-            print_api("Enabling Virtual Machine Platform...")
-            process.run_powershell_command(command)
-
-    # Set WSL version 2 as default.
-    if set_default_version_2:
-        print_api("Setting WSL version 2 as default...")
-        process.execute_with_live_output("wsl --set-default-version 2")
-
-    # Check if Ubuntu is already installed. If so, exit with a message.
-    if is_ubuntu_installed():
-        print_api("Ubuntu is already installed", color='green')
-        sys.exit(0)
-
-    # Before you install Ubuntu, you need to set the WSL to version 2.
-    # You can do it after you install, but if so, you will need to set the Ubuntu to version 2 either.
-    # Download and Install Ubuntu.
-    print_api("Installing Ubuntu for WSL...")
-    package_file_path: str = str(Path(directory_path, "Ubuntu.appx"))
-    process.run_powershell_command(
-        f"Invoke-WebRequest -Uri https://aka.ms/wslubuntu2204 -OutFile {package_file_path} -UseBasicParsing")
-    process.run_powershell_command(f"Add-AppxPackage {package_file_path}")
-
-    print_api("Ubuntu installation is complete. You can now launch Ubuntu from the Start Menu.")
-    print_api("Please restart your computer to complete the installation.")
-
-
-def install_wsl(distro: str = "Ubuntu-22.04"):
-    # noinspection GrazieInspection
-    """
-        Install WSL and Ubuntu.
-        :param distro: string, distro to install. Default is Ubuntu-22.04.
-        :return:
-
-        Main.py example:
-            from atomicshop.wrappers import wslw
-
-
-            def main():
-                wslw.install_wsl()
-
-
-            if __name__ == '__main__':
-                main()
-        """
-
-    # Check for admin privileges
-    if not permissions.is_admin():
-        print_api("Script must be run as administrator", color='red')
-        sys.exit(1)
-
-    # Check if virtualization is enabled.
-    if not virtualization.is_enabled():
-        print_api("Virtualization is not enabled in the bios. Please enable it and rerun the script.", color='red')
-        sys.exit(1)
-
-    # Check if WSL and Ubuntu is already installed
-    wsl_installed: bool = is_installed()
-    ubuntu_installed: bool = is_ubuntu_installed()
-
-    if wsl_installed and ubuntu_installed:
-        print_api("WSL and Ubuntu is already installed", color='green')
-        sys.exit(0)
-    elif wsl_installed and not ubuntu_installed:
-        print_api("WSL is already installed, installing Ubuntu")
-    elif not wsl_installed:
-        print_api("WSL is not installed, installing WSL and Ubuntu")
-
-    command = f"wsl --install -d {distro}"
-    process.execute_with_live_output(command, verbose=True)