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

atomicshop/pbtkmultifile_argparse.py

@@ -1,88 +0,0 @@
-# v1.0.1 - 26.03.2023 23:50
-import sys
-import argparse
-from argparse import RawTextHelpFormatter
-
-
-class ArgparseWrapper:
-    """
-    # Usage in the main:
-    args = ArgparseWrapper().parser_arguments
-    # Defining variables to each argument
-    input_path: str = args.input
-    output_path: str = args.output
-    """
-
-    def __init__(self):
-        self.application_short: str = 'pbtkMultiFile'
-        self.application_full: str = 'pbtk Multi File wrapper'
-        self.version: str = '1.0.0'
-        self.description: str = 'Find ".proto" files in directory of binaries.'
-        self.description_full: str = f'{self.application_full} v{self.version}\n' \
-                                     f'Description: {self.description}'
-        self.usage_variable: str = "%(prog)s [-h] -in folder_with_binary_files -out full_path_to_output_files\n" \
-                                   "Input or Output path shouldn't end with separator. Example: '\\'."
-        self.parser_arguments = None
-
-        # Execute argparse.
-        self.define_argparse()
-
-    # Function to define argument parser
-    def define_argparse(self):
-        # Create the parser
-        # formatter_class=RawTextHelpFormatter: shows raw text and not the default argparse text parsing.
-        parser = argparse.ArgumentParser(description=self.description_full,
-                                         usage=self.usage_variable,
-                                         formatter_class=RawTextHelpFormatter)
-
-        # Add arguments
-        parser.add_argument('-in', '--input',
-                            action='store', type=str, metavar='PATH_TO_FOLDER_WITH_BINARY_FILES',
-                            required=True,
-                            help='Provide full path to folder that contains binary files.')
-        parser.add_argument('-out', '--output', action='store', type=str, metavar='PATH_TO_SAVE_EXPORTED_FILES',
-                            required=True,
-                            help='Provide full path where you want to store exported file.')
-
-        # A problem before executing 'parse_args()'.
-        # If we get directory path as argument, on windows we can get a path that ends with backslash:
-        # C:\Users\user\documents\
-        # This is the default behaviour of windows when copying path of only the directory.
-        # When the path contains spaces, we need to pass it with double quotes:
-        # "C:\Users\user\documents\some folder name\another\"
-        # When python receives the arguments from CMD they get already parsed, meaning python can do nothing about it.
-        # From input:
-        # python_script.py -in "C:\some folder name\another\" -out "C:\some folder name\another1\"
-        # You will get output:
-        # ['python_script.py',
-        #   '-in',
-        #   'C:\some folder name\another" -out C:\some',
-        #   'folder',
-        #   'name\another1"]
-        # 'parse_args()' gets its input from 'sys.argv'. Meaning, you will need to do some manipulations on that
-        # Before executing the argparse argument parsing.
-        # Probably the fix should be individual for each case.
-        # The simplest solution though is to tell the user not to use backslash in the end of directory in case
-        # of exception.
-
-        try:
-            # Execute parse_args()
-            parsed_arguments = parser.parse_args()
-        # The only thing that you can catch on without modifying Argparse code is 'SystemExit' exception.
-        # You can also provide just 'except' without anything, which isn't the best practice.
-        # Another fix would be to use
-        # argparse.ArgumentParser(exit_on_error=False)
-        # But as of python 3.10.8 it is not working yet.
-        except SystemExit as exception_object:
-            print('======================================')
-            print('[*] Info: Error in provided arguments.')
-            print('[*] Tip: Check if you have backslash "\\" in the end of folder path, if so remove it.')
-            print('======================================')
-            sys.exit()
-
-        # if the folder path argument in the middle will have backslash "\" it will cause an exception.
-        # If the backslash will be in the end, it will not cause exception, but the string will end with double quotes.
-        parsed_arguments.input = parsed_arguments.input.replace('"', '')
-        parsed_arguments.output = parsed_arguments.output.replace('"', '')
-
-        self.parser_arguments = parsed_arguments

atomicshop/permissions.py

@@ -1,151 +0,0 @@
-import os
-import stat
-import ctypes
-import contextlib
-import subprocess
-
-# Import pwd only on linux.
-if os.name == 'posix':
-    import pwd
-
-
-def is_admin() -> bool:
-    """
-    Function checks on Windows or POSIX OSes if the script is executed under Administrative Privileges.
-    :return: True / False.
-    """
-
-    if os.name == 'nt':
-        if ctypes.windll.shell32.IsUserAnAdmin() == 0:
-            result = False
-        else:
-            result = True
-    else:
-        if 'SUDO_USER' in os.environ and os.geteuid() == 0:
-            result = True
-        else:
-            result = False
-
-    return result
-
-
-def get_ubuntu_sudo_executer_username() -> str:
-    """
-    Function gets the username of the user who executed the script with sudo.
-    :return: str, username.
-    """
-
-    if 'SUDO_USER' in os.environ:
-        return os.environ['SUDO_USER']
-    else:
-        return ''
-
-
-def set_executable_permission(file_path: str):
-    """
-    Function sets the executable permission on a file.
-    Equivalent to: chmod +x <file_path>
-
-    :param file_path: str, path to the file.
-    :return:
-    """
-
-    # os.chmod(file_path, os.stat(file_path).st_mode | 0o111)
-    os.chmod(file_path, os.stat(file_path).st_mode | stat.S_IXUSR)
-
-
-def change_file_owner_ubuntu(file_path: str, username: str):
-    """
-    Function changes the owner of the file to the specified user.
-    :param file_path: str, path to the file.
-    :param username: str, username of the new owner.
-    :return:
-    """
-
-    uid = pwd.getpwnam(username).pw_uid
-    os.chown(file_path, uid, -1)
-
-
-def is_executable_permission(file_path: str) -> bool:
-    """
-    Function checks if the file has the executable permission.
-    Equivalent to: stat -c "%a %n" <file_path>
-
-    :param file_path: str, path to the file.
-    :return: bool, True / False.
-    """
-
-    return bool(os.stat(file_path).st_mode & stat.S_IXUSR)
-
-
-def run_as_root(command):
-    subprocess.check_call(['sudo'] + command)
-
-
-@contextlib.contextmanager
-def temporary_regular_permissions():
-    """
-    This function is used to temporarily change the effective user and group ID to the original user's.
-    This is used to run commands with the original user's permissions.
-    If you executed a script with 'sudo' and wanted certain action to execute as regular user and not root.
-
-    Example:
-        with temporary_regular_permissions():
-            # Do something with regular permissions.
-            pass
-
-    :return:
-    """
-    # Save the current effective user and group ID
-    original_euid, original_egid = os.geteuid(), os.getegid()
-
-    try:
-        # Get the original user's UID and GID
-        orig_uid = int(os.environ.get('SUDO_UID', os.getuid()))
-        orig_gid = int(os.environ.get('SUDO_GID', os.getgid()))
-
-        # Set the effective user and group ID to the original user's
-        os.setegid(orig_gid)
-        os.seteuid(orig_uid)
-
-        # Provide the context to do something with these permissions
-        yield
-    finally:
-        # Revert to the original effective user and group ID
-        os.seteuid(original_euid)
-        os.setegid(original_egid)
-
-
-def expand_user_path(user_name, path):
-    pwnam = pwd.getpwnam(user_name)
-    home_dir = pwnam.pw_dir
-    return path.replace("~", home_dir)
-
-
-def unblock_file_windows(file_path):
-    """
-    Unblock a file on Windows. This is used to unblock files downloaded from the internet.
-    When you Right-click then navigate to Properties, you will see the Unblock checkbox.
-    :param file_path:
-    :return:
-    """
-    try:
-        subprocess.run(["powershell", "-Command", f"Unblock-File -Path '{file_path}'"], check=True)
-        print(f"Successfully unblocked the file: {file_path}")
-    except subprocess.CalledProcessError as e:
-        print(f"Failed to unblock the file: {file_path}\nError: {e}")
-
-
-def get_command_to_run_as_admin_windows(command: str) -> str:
-    """
-    Function returns the command to run a command as administrator on Windows.
-    :param command: str, command to run.
-    :return: str, command to run as administrator.
-    """
-
-    executable = command.split()[0]
-    command = (
-        f"powershell -Command "
-        f"\"Start-Process {executable} -ArgumentList '{' '.join(command.split()[1:])}' -Verb RunAs\"")
-
-    return command

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