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

atomicshop/wrappers/pycharmw.py

@@ -1,81 +0,0 @@
-import requests
-from bs4 import BeautifulSoup
-import subprocess
-
-from .. import web, filesystem
-from ..print_api import print_api
-
-
-# URL to the PyCharm Community Edition download page
-PYCHARM_DOWNLOAD_URL = 'https://www.jetbrains.com/pycharm/download/#section=windowsC'
-
-
-def download_install_main():
-    """
-    Main function to download and install the latest PyCharm Community Edition.
-
-    Usage:
-    python -m atomicshop.mains.installs.pycharm
-
-    Or run the main function directly.
-        from atomicshop.wrappers import pycharmw
-
-
-        def main():
-            pycharmw.download_install_main()
-
-
-        if __name__ == "__main__":
-            main()
-    """
-
-    def get_latest_pycharm_download_link():
-        url = "https://www.jetbrains.com/pycharm/download/"
-        headers = {
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
-        }
-
-        response = requests.get(url, headers=headers)
-        if response.status_code != 200:
-            raise Exception("Failed to load the download page")
-
-        soup = BeautifulSoup(response.text, 'html.parser')
-        download_link = None
-
-        # Find the Professional version download link
-        for a in soup.find_all('a', href=True):
-            if '/download?code=PCC&platform=windows' in a['href']:
-                download_link = a['href']
-                break
-
-        if not download_link:
-            raise Exception("Could not find the download link for the latest version of PyCharm Professional")
-
-        return f"https:{download_link}"
-
-    installer_path: str = None
-    try:
-        print_api("Fetching the latest PyCharm download link...")
-        download_url = get_latest_pycharm_download_link()
-        print_api(f"Download URL: {download_url}")
-
-        print_api("Starting the download...")
-        file_name = "pycharm-latest.exe"
-        # download_file(download_url, file_name)
-        installer_path = web.download(file_url=download_url, file_name=file_name)
-        print_api(f"Downloaded the latest version of PyCharm to {file_name}", color='green')
-    except Exception as e:
-        print_api(f"An error occurred: {e}")
-
-    if not installer_path:
-        print_api("Failed to download the latest version of PyCharm", color='red')
-        return 1
-
-    # Install PyCharm
-    # Run the installer
-    print_api("Running the installer...")
-    subprocess.run([installer_path, '/S'], check=True)  # /S for silent installation
-    print_api("Installation complete.", color='green')
-
-    # Remove the installer
-    filesystem.remove_file(installer_path)

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)