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

atomicshop/process_poller.py

@@ -1,237 +0,0 @@
-import threading
-import multiprocessing
-import time
-from typing import Literal, Union
-
-from .wrappers.pywin32w import wmi_win32process
-from .wrappers.psutilw import psutilw
-from .basics import list_of_dicts, dicts
-from .process_name_cmd import ProcessNameCmdline
-
-
-def get_process_time_tester(
-        get_method: Literal['psutil', 'pywin32', 'process_dll'] = 'process_dll',
-        times_to_test: int = 50
-):
-    """
-    The function will test the time it takes to get the list of processes with different methods and cycles.
-
-    :param get_method: str, The method to get the list of processes. Default is 'process_list_dll'.
-        'psutil': Get the list of processes by 'psutil' library. Resource intensive and slow.
-        'pywin32': Get the list of processes by 'pywin32' library, using WMI. Not resource intensive, but slow.
-        'process_dll'. Not resource intensive and fast. Probably works only in Windows 10 x64
-    :param times_to_test: int, how many times to test the function.
-    """
-
-    import timeit
-
-    setup_code = '''
-from atomicshop import process_poller
-get_process_list = process_poller.GetProcessList(get_method=get_method, connect_on_init=True)
-'''
-
-    test_code = '''
-test = get_process_list.get_processes()
-'''
-
-    # globals need to be specified, otherwise the setup_code won't work with passed variables.
-    times = timeit.timeit(setup=setup_code, stmt=test_code, number=times_to_test, globals=locals())
-    print(f'Execution time: {times}')
-
-
-class GetProcessList:
-    def __init__(
-            self,
-            get_method: Literal['psutil', 'pywin32', 'process_dll'] = 'process_dll',
-            connect_on_init: bool = False
-    ):
-        """
-        :param get_method: str, The method to get the list of processes. Default is 'process_list_dll'.
-            'psutil': Get the list of processes by 'psutil' library. Resource intensive and slow.
-            'pywin32': Get the list of processes by 'pywin32' library, using WMI. Not resource intensive, but slow.
-            'process_dll'. Not resource intensive and fast. Probably works only in Windows 10 x64
-        :param connect_on_init: bool, if True, will connect to the service on init. 'psutil' don't need to connect.
-        """
-        self.get_method = get_method
-        self.process_polling_instance = None
-
-        self.connected = False
-
-        if self.get_method == 'psutil':
-            self.process_polling_instance = psutilw.PsutilProcesses()
-            self.connected = True
-        elif self.get_method == 'pywin32':
-            self.process_polling_instance = wmi_win32process.Pywin32Processes()
-        elif self.get_method == 'process_dll':
-            self.process_polling_instance = ProcessNameCmdline()
-
-        if connect_on_init:
-            self.connect()
-
-    def connect(self):
-        """
-        Connect to the service. 'psutil' don't need to connect.
-        """
-
-        # If the service is not connected yet. Since 'psutil' don't need to connect.
-        if not self.connected:
-            if self.get_method == 'pywin32':
-                self.process_polling_instance.connect()
-                self.connected = True
-            elif self.get_method == 'process_dll':
-                self.process_polling_instance.load()
-                self.connected = True
-
-    def get_processes(self, as_dict: bool = True) -> Union[list, dict]:
-        """
-        The function will get the list of opened processes and return it as a list of dicts.
-
-        :return: list of dicts, of opened processes.
-        """
-
-        if as_dict:
-            if self.get_method == 'psutil':
-                return self.process_polling_instance.get_processes_as_dict(
-                    attrs=['pid', 'name', 'cmdline'], cmdline_to_string=True)
-            elif self.get_method == 'pywin32':
-                processes = self.process_polling_instance.get_processes_as_dict(
-                    attrs=['ProcessId', 'Name', 'CommandLine'])
-
-                # Convert the keys from WMI to the keys that are used in 'psutil'.
-                converted_process_dict = dict()
-                for pid, process_info in processes.items():
-                    converted_process_dict[pid] = dicts.convert_key_names(
-                        process_info, {'Name': 'name', 'CommandLine': 'cmdline'})
-
-                return converted_process_dict
-            elif self.get_method == 'process_dll':
-                return self.process_polling_instance.get_process_details(as_dict=True)
-        else:
-            if self.get_method == 'psutil':
-                return self.process_polling_instance.get_processes_as_list_of_dicts(
-                    attrs=['pid', 'name', 'cmdline'], cmdline_to_string=True)
-            elif self.get_method == 'pywin32':
-                processes = self.process_polling_instance.get_processes_as_list_of_dicts(
-                    attrs=['ProcessId', 'Name', 'CommandLine'])
-
-                # Convert the keys from WMI to the keys that are used in 'psutil'.
-                for process_index, process_info in enumerate(processes):
-                    processes[process_index] = dicts.convert_key_names(
-                        process_info, {'ProcessId': 'pid', 'Name': 'name', 'CommandLine': 'cmdline'})
-
-                return processes
-            elif self.get_method == 'process_dll':
-                return self.process_polling_instance.get_process_details(as_dict=as_dict)
-
-
-class ProcessPollerPool:
-    """
-    The class is responsible for polling processes and storing them in a pool.
-    Currently, this works with 'psutil' library and takes up to 16% of CPU on my machine.
-    Because 'psutil' fetches 'cmdline' for each 'pid' dynamically, and it takes time and resources
-    Later, I'll find a solution to make it more efficient.
-    """
-    def __init__(
-            self, store_cycles: int = 200,
-            interval_seconds: Union[int, float] = 0,
-            operation: Literal['thread', 'process'] = 'thread',
-            poller_method: Literal['psutil', 'pywin32', 'process_dll'] = 'process_dll'
-    ):
-        """
-        :param store_cycles: int, how many cycles to store. Each cycle is polling processes.
-            Example: Specifying 3 will store last 3 polled cycles of processes.
-
-            Default is 200, which means that 200 latest cycles original PIDs and their process names will be stored.
-
-            You can execute the 'get_process_time_tester' function in order to find the optimal number of cycles
-            and how much time it will take.
-        :param interval_seconds: float, how many seconds to wait between each cycle.
-            Default is 0, which means that the polling will be as fast as possible.
-
-            Basically, you want it to be '0' if you want to get the most recent processes.
-            Any polling by itself takes time, so if you want to get the most recent processes, you want to do it as fast
-            as possible.
-        :param operation: str, 'thread' or 'process'. Default is 'process'.
-            'process': The polling will be done in a new process.
-            'thread': The polling will be done in a new thread.
-
-            Python is slow, if you are going to use 'thread' all other operations inside this thread will be very slow.
-            You can even get exceptions, if you're using process polling for correlations of PIDs and process names.
-            It is advised to use the 'process' operation, which will not affect other operations in the thread.
-        :param poller_method: str. Default is 'process_dll'. Available:
-            'psutil': Get the list of processes by 'psutil' library. Resource intensive and slow.
-            'pywin32': Get the list of processes by 'pywin32' library, using WMI. Not resource intensive, but slow.
-            'process_dll'. Not resource intensive and fast. Probably works only in Windows 10 x64.
-        """
-
-        self.store_cycles: int = store_cycles
-        self.interval_seconds: float = interval_seconds
-        self.operation: str = operation
-        self.poller_method = poller_method
-
-        self.get_processes_list = GetProcessList(get_method=self.poller_method)
-
-        # Current process pool.
-        self.processes: dict = dict()
-
-        # The variable is responsible to stop the thread if it is running.
-        self.running: bool = False
-
-        self.queue = multiprocessing.Queue()
-
-    def start(self):
-        if self.operation == 'thread':
-            self._start_thread()
-        elif self.operation == 'process':
-            self._start_process()
-        else:
-            raise ValueError(f'Invalid operation type [{self.operation}]')
-
-    def stop(self):
-        self.running = False
-
-    def _start_thread(self):
-        self.running = True
-        # threading.Thread(target=self._worker, args=(self.process_polling_instance,)).start()
-        threading.Thread(target=self._worker).start()
-
-    def _start_process(self):
-        self.running = True
-        multiprocessing.Process(target=self._worker).start()
-        threading.Thread(target=self._thread_get_queue).start()
-
-    # def _worker(self, process_polling_instance):
-    def _worker(self):
-        # We must initiate the connection inside the thread/process, because it is not thread-safe.
-        self.get_processes_list.connect()
-
-        list_of_processes: list = list()
-        while self.running:
-            # If the list is full (to specified 'store_cycles'), remove the first element.
-            if len(list_of_processes) == self.store_cycles:
-                del list_of_processes[0]
-
-            # Get the current processes and reinitialize the instance of the dict.
-            current_processes: dict = dict(self.get_processes_list.get_processes())
-
-            # Remove Command lines that contains only numbers, since they are useless.
-            for pid, process_info in current_processes.items():
-                if process_info['cmdline'].isnumeric():
-                    current_processes[pid]['cmdline'] = str()
-                elif process_info['cmdline'] == 'Error':
-                    current_processes[pid]['cmdline'] = str()
-
-            # Append the current processes to the list.
-            list_of_processes.append(current_processes)
-
-            # Merge all dicts in the list to one dict, updating with most recent PIDs.
-            self.processes = list_of_dicts.merge_to_dict(list_of_processes)
-
-            if self.operation == 'process':
-                self.queue.put(self.processes)
-
-            time.sleep(self.interval_seconds)
-
-    def _thread_get_queue(self):
-        while True:
-            self.processes = self.queue.get()

atomicshop/script_as_string_processor.py

@@ -1,38 +0,0 @@
-"""Loading resources using stdlib importlib.resources APIs (Python 3.7+)
-https://docs.python.org/3/library/importlib.html#module-importlib.resources"""
-import importlib.resources
-
-from .print_api import print_api
-
-
-class ScriptAsStringProcessor:
-    def __init__(self):
-        self.resources_directory_name: str = 'ssh_scripts'
-
-        # string variable that is going to be exchanged with variable from main script.
-        self.exchange_input_variable_string: str = "exchange_input_variable"
-        self.script_string: str = str()
-
-    def read_script_to_string(self, script_file_name: str):
-        self.script_string = importlib.resources.read_text(
-            f'{__package__}.{self.resources_directory_name}',
-            f'{script_file_name}.py')
-
-        return self
-
-    def put_variable_into_script_string(self, input_variable: any, print_kwargs: dict = None):
-        # Defining variables
-        function_result: str = str()
-
-        if self.exchange_input_variable_string in self.script_string:
-            # string.replace(old, new, count)
-            # old – old substring you want to replace.
-            # new – new substring which would replace the old substring.
-            # count – the number of times you want to replace the old substring with the new substring. (Optional)
-            # We want to replace our string only one time in the beginning.
-            function_result = self.script_string.replace(self.exchange_input_variable_string, str(input_variable), 1)
-        else:
-            message = f"The script string provided doesn't contain {self.exchange_input_variable_string}"
-            print_api(message, error_type=True, logger_method='error', **print_kwargs)
-
-        return function_result

atomicshop/ssh_scripts/process_from_ipv4.py

@@ -1,37 +0,0 @@
-# importing the psutil library to get the source ports and get the process full command line from it.
-import psutil
-# 'psutil.Process(connection.pid).cmdline()' returns list of full command line parts, it is needed to reassemble
-# these parts to regular command line string.
-import shlex
-
-
-# User defined exception.
-class StopAllIterations(Exception):
-    pass
-
-
-# 'input_variable' will be string exchanged in the real script. It is the first line, so it won't take time to find the
-# line for the main script.
-# noinspection PyUnresolvedReferences
-remote_ipv4_list = exchange_input_variable
-
-
-try:
-    # for iteration in range(100):
-    # Iterating through all the connections on the computer.
-    for connection in psutil.net_connections(kind='all'):
-        # 'connection.raddr' is a tuple consisting of IPv4 address [0] and the port [1].
-        # Sometimes, if there's no remote address, "raddr" will be empty and since it's a tuple, we need to check that
-        # before getting the first [0] index.
-        if connection.raddr:
-            for address in remote_ipv4_list:
-                if connection.raddr[0] == address:
-                    # Get the command line from the connection PID.
-                    command_line = psutil.Process(connection.pid).cmdline()
-                    # Command line object is returned as list of parameters. We need 'shlex.join' to join the iterables
-                    # to regular, readable string.
-                    print(shlex.join(command_line))
-                    # Break the loops, when first match is found.
-                    raise StopAllIterations
-except StopAllIterations:
-    pass

atomicshop/ssh_scripts/process_from_port.py

@@ -1,27 +0,0 @@
-# importing the psutil library to get the source ports and get the process full command line from it.
-import psutil
-# 'psutil.Process(connection.pid).cmdline()' returns list of full command line parts, it is needed to reassemble
-# these parts to regular command line string.
-import shlex
-
-# 'input_variable' will be string exchanged in the real script. It is the first line, so it won't take time to find the
-# line for the main script.
-# noinspection PyUnresolvedReferences
-source_port = exchange_input_variable
-
-# Iterating through all the connections on the computer.
-for connection in psutil.net_connections():
-    # 'connection.laddr' is a tuple consisting of IPv4 address [0] and the port [1].
-    if connection.laddr[1] == source_port:
-        # Get the command line from the connection PID.
-        command_line = psutil.Process(connection.pid).cmdline()
-        # Command line object is returned as list of parameters. We need 'shlex.join' to join the iterables
-        # to regular, readable string.
-        result = shlex.join(command_line)
-        # If the result is still a PID, we'll try to get process name.
-        if result.isnumeric():
-            # Get the process name from the connection PID.
-            result = psutil.Process(connection.pid).name()
-        print(result)
-        # Break the loop, when first match is found.
-        break

atomicshop/wrappers/_process_wrapper_curl.py

@@ -1,27 +0,0 @@
-# v1.0.2 - 21.03.2023 13:40
-import sys
-import shlex
-
-from .. import process
-from .. import web
-
-
-def download_file_with_curl(file_url: str, target_directory: str) -> None:
-    """
-    The function receives url and target filesystem directory to download the file.
-
-    :param file_url: full URL to download the file.
-    :param target_directory: The directory on the filesystem to save the file to.
-    """
-
-    # Get only the filename from URL.
-    file_name = web.get_filename_from_url(file_url=file_url)
-
-    cmd: str = f'curl -L {file_url} --output "{target_directory}"'
-    cmd_list: list = shlex.split(cmd)
-
-    output_list: list = process.execute_with_live_output(cmd=cmd_list)
-    # If there was error in curl.
-    if 'curl: ' in output_list[-1]:
-        print('Curl error. Exiting...')
-        sys.exit()

atomicshop/wrappers/_process_wrapper_tar.py

@@ -1,21 +0,0 @@
-# v1.0.2 - 21.03.2023 18:30
-import shlex
-
-from .. import process
-
-
-def extract_archive_with_tar(file_path: str, target_directory: str) -> None:
-    """
-    Function extracts the archive to target directory.
-
-    :param file_path: Full file path to archived file to extract.
-    :param target_directory: The directory on the filesystem to extract the file to.
-    :return: None
-    """
-
-    # -v: Verbose, shows list of extracted files.
-    # -C: Output directory.
-    cmd: str = f'tar -xzvf "{file_path}" -C "{target_directory}"'
-    cmd_list: list = shlex.split(cmd)
-
-    output_list = process.execute_with_live_output(cmd=cmd_list)

atomicshop/wrappers/dockerw/install_docker.py

@@ -1,209 +0,0 @@
-import sys
-import subprocess
-import getpass
-
-from ... import process, filesystem, permissions
-from ...print_api import print_api
-from .. import ubuntu_terminal
-
-
-def is_docker_installed():
-    """
-    The function will check if docker is installed.
-    :return: bool.
-    """
-
-    try:
-        # Run the command 'docker --version'
-        result = subprocess.run(['docker', '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-
-        # Check if the command was successful
-        if result.returncode == 0:
-            message = f"Docker is installed. Version: {result.stdout.strip()}"
-            print_api(message, color='green')
-            return True
-        else:
-            print_api("Docker is not installed.")
-            return False
-    except FileNotFoundError:
-        print_api("Docker command not found. Docker is not installed.")
-        return False
-
-
-def add_current_user_to_docker_group(print_kwargs: dict = None):
-    """
-    The function will add the current user to the docker group.
-
-    :param print_kwargs: dict, the print arguments.
-    :return:
-    """
-    # Check if current user that executed the script is a sudo user. If not, use the current user.
-    sudo_executer_username: str = permissions.get_ubuntu_sudo_executer_username()
-    if sudo_executer_username:
-        current_user = sudo_executer_username
-    else:
-        current_user = getpass.getuser()
-
-    # Add the current user to the docker group.
-    # subprocess.check_call(['sudo', 'usermod', '-aG', 'docker', current_user])
-    command = f"sudo usermod -aG docker {current_user}"
-    # Execute the command
-    subprocess.run(command, shell=True, capture_output=True, text=True)
-
-    # Check if the user was added to the docker group.
-    result = subprocess.run(['groups', current_user], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-    if 'docker' in result.stdout:
-        print_api(f"User {current_user} was added to the docker group.", color='green', **(print_kwargs or {}))
-        return True
-    else:
-        print_api(f"User {current_user} was not added to the docker group. Try executing with sudo", color='red',
-                  **(print_kwargs or {}))
-        return 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.
-    Note: If you want to install docker in rootless mode, you need to run the script without sudo.
-
-    :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. 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
-
-
-        def main():
-            install_docker.install_docker_ubuntu()
-
-
-        if __name__ == '__main__':
-            main()
-    """
-
-    if rootless and permissions.is_admin():
-        print_api('Rootless installation requires running the script without sudo.', color='red')
-        sys.exit()
-
-    if use_docker_installer:
-        if not ubuntu_terminal.is_executable_exists('curl'):
-            print_api('curl is not installed, installing...', color='yellow')
-            ubuntu_terminal.update_system_packages()
-            ubuntu_terminal.install_packages(['curl'])
-
-        # 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)
-        process.execute_script('curl -fsSL https://get.docker.com | sh', shell=True)
-        # process.execute_script('curl -fsSL https://get.docker.com -o get-docker.sh', shell=True)
-        # process.execute_script('sh get-docker.sh', shell=True)
-        # filesystem.remove_file('get-docker.sh')
-    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 docker-ce-rootless-extras
-        
-        # 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.
-        if not ubuntu_terminal.is_package_installed('uidmap'):
-            print_api('uidmap is not installed, installing...', color='yellow')
-            ubuntu_terminal.update_system_packages()
-            ubuntu_terminal.install_packages(['uidmap'])
-
-        with permissions.temporary_regular_permissions():
-            # After 'get-docker.sh' execution, we will install docker in rootless mode.
-            # process.execute_script('dockerd-rootless-setuptool.sh install', shell=True, as_regular_user=True)
-            process.execute_script(
-                '/usr/bin/dockerd-rootless-setuptool.sh install',
-                as_regular_user=True,
-                shell=True,
-                executable=None)
-
-        # Start and enable the docker service in user mode.
-        docker_start_command = ubuntu_terminal.get_command_execution_as_sudo_executer(
-            'systemctl --user start docker.service')
-        docker_enable_command = ubuntu_terminal.get_command_execution_as_sudo_executer(
-            'systemctl --user enable docker.service')
-        print_api('Starting and enabling the docker service in user mode...')
-        process.execute_script(docker_start_command, shell=True, executable=None)
-        process.execute_script(docker_enable_command, shell=True, executable=None)
-
-        print_api('Executing "loginctl enable-linger" to enable Docker to run when the user is not logged in...')
-        non_sudo_executer = permissions.get_ubuntu_sudo_executer_username()
-        # Enable lingering so Docker runs when the user is not logged in
-        process.execute_script(f'sudo loginctl enable-linger {non_sudo_executer}', shell=True)
-
-        print_api('Adding $HOME/bin to your PATH...')
-        # Add $HOME/bin to your PATH if it's not already there.
-        with permissions.temporary_regular_permissions():
-            ubuntu_terminal.add_path_to_bashrc(as_regular_user=True)
-
-        # Add appropriate permissions to the docker socket, so the user can run docker commands without sudo in python.
-        # with open('/etc/profile.d/docker_vars.sh', 'w') as file:
-        #     file.write('export DOCKER_HOST=unix:///run/user/1000/docker.sock')
-
-        # Since we are installing the rootless mode, this script runs without sudo, so to add the DOCKER_HOST variable
-        # to the environment, we need to add it to the /etc/profile.d/docker_vars.sh file with sudo.
-        command = "echo 'export DOCKER_HOST=unix:///run/user/1000/docker.sock' | sudo tee /etc/profile.d/docker_vars.sh"
-        subprocess.run(command, shell=True, check=True)
-
-        # ubuntu_terminal.add_line_to_bashrc(
-        #     'export DOCKER_HOST=unix:///run/user/1000/docker.sock', as_regular_user=True)
-        # process.execute_script('export DOCKER_HOST=unix:///run/user/1000/docker.sock', shell=True)
-        # Restart shell.
-        # process.execute_script('source ~/.bashrc', shell=True)
-
-    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')
-    else:
-        result: list = process.execute_with_live_output('docker run hello-world')
-
-    print_api('\n'.join(result))
-
-    if 'Hello from Docker!' in '\n'.join(result):
-        print_api('Docker installed successfully.', color='green')
-        return True
-    else:
-        print_api('Docker installation failed.', color='red')
-        print_api('Please check the logs above for more information.', color='red')
-        return False