atomicshop 2.15.13__py3-none-any.whl → 2.16.1__py3-none-any.whl

atomicshop/permissions/permissions.py

@@ -0,0 +1,22 @@
+import os
+import ctypes
+
+
+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

atomicshop/{permissions.py → permissions/ubuntu_permissions.py}

@@ -1,6 +1,5 @@
 import os
 import stat
-import ctypes
 import contextlib
 import subprocess
 
@@ -9,27 +8,7 @@ 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:
+def get_sudo_executer_username() -> str:
     """
     Function gets the username of the user who executed the script with sudo.
     :return: str, username.
@@ -41,7 +20,7 @@ def get_ubuntu_sudo_executer_username() -> str:
         return ''
 
 
-def set_executable_permission(file_path: str):
+def set_executable(file_path: str):
     """
     Function sets the executable permission on a file.
     Equivalent to: chmod +x <file_path>
@@ -54,7 +33,7 @@ def set_executable_permission(file_path: str):
     os.chmod(file_path, os.stat(file_path).st_mode | stat.S_IXUSR)
 
 
-def change_file_owner_ubuntu(file_path: str, username: str):
+def change_file_owner(file_path: str, username: str):
     """
     Function changes the owner of the file to the specified user.
     :param file_path: str, path to the file.
@@ -66,7 +45,7 @@ def change_file_owner_ubuntu(file_path: str, username: str):
     os.chown(file_path, uid, -1)
 
 
-def is_executable_permission(file_path: str) -> bool:
+def is_executable(file_path: str) -> bool:
     """
     Function checks if the file has the executable permission.
     Equivalent to: stat -c "%a %n" <file_path>
@@ -120,32 +99,3 @@ 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/permissions/win_permissions.py

@@ -0,0 +1,33 @@
+import subprocess
+
+
+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.
+    NOTE: When you run something this way, the parent will be the powershell.exe process.
+        If you need a status result directly of the executed command, you need to use subprocess.run() instead.
+
+    :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,6 +1,7 @@
 """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 typing import Literal
 
 from .print_api import print_api
 
@@ -13,7 +14,10 @@ class ScriptAsStringProcessor:
         self.exchange_input_variable_string: str = "exchange_input_variable"
         self.script_string: str = str()
 
-    def read_script_to_string(self, script_file_name: str):
+    def read_script_to_string(
+            self,
+            script_file_name: Literal['process_from_port', 'process_from_ipv4']
+    ):
         self.script_string = importlib.resources.read_text(
             f'{__package__}.{self.resources_directory_name}',
             f'{script_file_name}.py')

atomicshop/wrappers/cryptographyw.py

@@ -80,7 +80,7 @@ def convert_pem_to_x509_object(certificate: Union[str, bytes]) -> x509.Certifica
     return x509.load_pem_x509_certificate(certificate)
 
 
-def convert_der_to_x509_object(certificate: bytes):
+def convert_der_to_x509_object(certificate: bytes) -> x509.Certificate:
     """Convert DER certificate from socket to x509 object.
 
     :param certificate: bytes, certificate to convert.
@@ -151,8 +151,8 @@ def copy_extensions_from_old_cert_to_new_cert(
     builder = x509.CertificateBuilder()
     builder = builder.subject_name(certificate.subject)
     builder = builder.issuer_name(certificate.issuer)
-    builder = builder.not_valid_before(certificate.not_valid_before)
-    builder = builder.not_valid_after(certificate.not_valid_after)
+    builder = builder.not_valid_before(certificate.not_valid_before_utc)
+    builder = builder.not_valid_after(certificate.not_valid_after_utc)
     builder = builder.serial_number(certificate.serial_number)
 
     # We're using the new private key that we will sign with the new certificate later.

atomicshop/wrappers/dockerw/install_docker.py

@@ -2,7 +2,8 @@ import sys
 import subprocess
 import getpass
 
-from ... import process, filesystem, permissions
+from ... import process, filesystem
+from ...permissions import permissions, ubuntu_permissions
 from ...print_api import print_api
 from .. import ubuntu_terminal
 
@@ -38,7 +39,7 @@ def add_current_user_to_docker_group(print_kwargs: dict = None):
     :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()
+    sudo_executer_username: str = ubuntu_permissions.get_sudo_executer_username()
     if sudo_executer_username:
         current_user = sudo_executer_username
     else:
@@ -145,7 +146,7 @@ def install_docker_ubuntu(
             ubuntu_terminal.update_system_packages()
             ubuntu_terminal.install_packages(['uidmap'])
 
-        with permissions.temporary_regular_permissions():
+        with ubuntu_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(
@@ -164,13 +165,13 @@ def install_docker_ubuntu(
         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()
+        non_sudo_executer = ubuntu_permissions.get_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():
+        with ubuntu_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.

atomicshop/wrappers/elasticsearchw/install_elastic.py

@@ -1,7 +1,8 @@
 import sys
 
 from ...print_api import print_api
-from ... import process, permissions
+from ... import process
+from ...permissions import permissions
 from .. import ubuntu_terminal
 from . import config_basic, infrastructure
 

atomicshop/wrappers/factw/install/pre_install_and_install_before_restart.py

@@ -2,7 +2,8 @@ import sys
 import subprocess
 from pathlib import Path
 
-from .... import permissions, filesystem
+from .... import filesystem
+from ....permissions import ubuntu_permissions
 from ....archiver import zips
 from ....print_api import print_api
 from ... import githubw, pipw, ubuntu_terminal
@@ -42,7 +43,7 @@ def install_before_restart(
     #     sys.exit(1)
 
     # # Install docker in rootless mode.
-    # with permissions.temporary_regular_permissions():
+    # with ubuntu_permissions.temporary_regular_permissions():
     #     install_docker.install_docker_ubuntu(
     #         use_docker_installer=True, rootless=True, add_current_user_to_docker_group_bool=False)
 
@@ -59,7 +60,7 @@ def install_before_restart(
         filesystem.remove_directory(installation_directory)
 
     # Since you run the script with sudo, we need to change the permissions to the current user.
-    # with permissions.temporary_regular_permissions():
+    # with ubuntu_permissions.temporary_regular_permissions():
     # Create the FACT_core directory.
     filesystem.create_directory(installation_directory)
 
@@ -78,7 +79,7 @@ def install_before_restart(
             remove_first_directory=True, **(print_kwargs or {}))
 
     # Set the executable permission on the pre-installation file.
-    permissions.set_executable_permission(fact_core_pre_install_file_path)
+    ubuntu_permissions.set_executable(fact_core_pre_install_file_path)
 
     if use_built_in_fact_installer:
         # Run the shell script

atomicshop/wrappers/mongodbw/install_mongodb.py

@@ -4,7 +4,8 @@ from typing import Union
 import argparse
 import subprocess
 
-from ... import urls, web, permissions
+from ... import urls, web
+from ...permissions import permissions
 from ...print_api import print_api
 from .. import msiw
 from . import infrastructure

atomicshop/wrappers/msiw.py

@@ -1,8 +1,7 @@
 import subprocess
-import sys
 
 from ..print_api import print_api
-from .. import permissions
+from ..permissions import permissions
 from ..import get_process_list
 from .psutilw import processes
 
@@ -124,7 +123,7 @@ def install_msi(
         command = f"{command} {additional_args}"
 
     # if as_admin:
-    #     command = permissions.get_command_to_run_as_admin_windows(command)
+    #     command = win_permissions.get_command_to_run_as_admin_windows(command)
 
     # Run the command
     result = subprocess.run(command, capture_output=True, text=True)

atomicshop/wrappers/psutilw/networks.py

@@ -1,5 +1,6 @@
 from typing import Union
 import shlex
+import socket
 
 import psutil
 
@@ -14,7 +15,10 @@ def get_process_using_port(port: int) -> Union[dict, None]:
         try:
             connections = proc.connections(kind='inet')
             for conn in connections:
-                if conn.laddr.port == port:
+                # if conn.laddr.port == port:
+                # Status LISTEN is for TCP sockets and NONE is for UDP sockets.
+                # Sometimes after socket close, the port will be in TIME_WAIT state.
+                if conn.laddr.port == port and (conn.status == 'LISTEN' or conn.status == 'NONE'):
                     cmdline = proc.info['cmdline']
                     if not cmdline:
                         cmdline = '<EMPTY: TRY RUNNING AS ADMIN>'
@@ -43,3 +47,23 @@ def get_processes_using_port_list(ports: list) -> Union[dict, None]:
             port_process_map[port] = process_info
 
     return port_process_map
+
+
+def get_default_connection_name() -> Union[dict, None]:
+    """
+    Function to get the default network interface.
+    :return: dict[interface_name: details] or None.
+    """
+    # Get all interfaces.
+    interfaces: dict = psutil.net_if_addrs()
+    default_ip_address: str = socket.gethostbyname(socket.gethostname())
+
+    for interface, details in interfaces.items():
+        for address in details:
+            # Check if the address is an IPv4 address (AF_INET) and not a loopback (127.0.0.1)
+            if address.family == socket.AF_INET and not address.address.startswith('127.'):
+                # Check if the address is the default IP address.
+                if address.address == default_ip_address:
+                    return {interface: details}
+
+    return None

atomicshop/wrappers/pycharmw/ubuntu.py

@@ -0,0 +1,38 @@
+import argparse
+
+from ... import process
+from ...print_api import print_api
+
+
+def parse_args():
+    """
+    Parse command line arguments.
+
+    :return: Parsed arguments.
+    """
+    parser = argparse.ArgumentParser(description='Install PyCharm Community Edition.')
+    parser.add_argument('--install', action='store_true', help='Install PyCharm Community Edition with snapd.')
+    parser.add_argument('--enable_sudo_execution', action='store_true',
+                        help='There is a problem when trying to run snapd installed Pycharm as sudo, need to enable '
+                             'this.')
+
+    return parser.parse_args()
+
+
+def install_main():
+    """
+    Main function to install the latest PyCharm Community Edition.
+
+    Usage:
+    python -m atomicshop.a_installs.ubuntu.pycharm
+    """
+
+    args = parse_args()
+
+    if args.install:
+        process.execute_script('sudo snap install pycharm-community --classic', shell=True)
+
+    if args.enable_sudo_execution:
+        process.execute_script('xhost +SI:localuser:root', shell=True)
+        print_api('Run the following command to start PyCharm as root: [sudo snap run pycharm-community]', color='blue')
+    return 0

atomicshop/wrappers/{pycharmw.py → pycharmw/win.py}

@@ -2,8 +2,8 @@ import requests
 from bs4 import BeautifulSoup
 import subprocess
 
-from .. import web, filesystem
-from ..print_api import print_api
+from ... import web, filesystem
+from ...print_api import print_api
 
 
 # URL to the PyCharm Community Edition download page

atomicshop/wrappers/pywin32w/wmis/helpers.py

@@ -0,0 +1,127 @@
+import win32com.client
+
+
+class WmiMethodExecutionError(Exception):
+    pass
+
+
+class WmiMethodParameterError(Exception):
+    pass
+
+
+class EmptyValue:
+    pass
+
+
+def get_method(
+        wmi_object: win32com.client.CDispatch,
+        method_name: str
+):
+    """
+    Get the WMI method.
+
+    :param wmi_object: WMI object.
+    :param method_name: str, name of the method.
+    :return: WMI method object.
+    """
+
+    return wmi_object.Methods_(method_name)
+
+
+def get_method_parameter_instance(
+        method: win32com.client.CDispatch
+):
+    """
+    Get the WMI method parameter.
+
+    :param method: WMI method object.
+    :return: WMI method parameter object.
+    """
+
+    return method.inParameters.SpawnInstance_()
+
+
+def call_method(
+        wmi_object: win32com.client.CDispatch,
+        method_name: str,
+        value: any = EmptyValue
+):
+    """
+    Call the WMI method.
+
+    :param wmi_object: WMI object.
+    :param method_name: str, name of the method.
+    :param value: any, value to pass to the method.
+        Methods can receive a None value if they don't require any parameters.
+        If the method doesn't require any parameters, leave it as 'EmptyValue' class.
+    :return: WMI method object.
+    """
+
+    # Get the method instance out of the WMI object.
+    method = get_method(wmi_object, method_name)
+
+    # Check if the method requires any parameters.
+    if not method.InParameters and not isinstance(value, EmptyValue):
+        raise WmiMethodParameterError(f"Method '{method_name}' doesn't require any parameters.\nValue: {value}")
+    elif method.InParameters and isinstance(value, EmptyValue):
+        raise WmiMethodParameterError(f"Method '{method_name}' requires parameters.\nValue: {value}")
+
+    # If value was passed for the method to set.
+    if not isinstance(value, EmptyValue):
+        # Get the input parameters names that a method requires.
+        # The names are stored in a list of tuples where the first element is the name of the parameter and the second
+        # element is a boolean that indicates if the parameter is an array.
+        input_parameters_names = [
+            (input_parameter.Name, input_parameter.IsArray) for input_parameter in method.InParameters.Properties_]
+
+        # Check if the value and the input parameter is a list.
+        if not (isinstance(value, list) or value is None) and input_parameters_names[0][1]:
+            raise WmiMethodParameterError(f"Parameter '{input_parameters_names[0][0]}' must be a list.\nValue: {value}")
+        elif (isinstance(value, list) or value is None) and not input_parameters_names[0][1]:
+            raise WmiMethodParameterError(f"Parameter '{input_parameters_names[0][0]}' "
+                                          f"must be a single value.\nValue: {value}")
+
+        # Get generic parameter instance.
+        parameter_instance = get_method_parameter_instance(method)
+        # Set the attribute of the parameter name instance that we retrieved from above to the value.
+        # At this point only been using one parameter for a method, so maybe need to refactor this part if needed
+        # in the future for more than one parameter.
+        setattr(parameter_instance, input_parameters_names[0][0], value)
+
+        # Execute the method with the parameter instance.
+        result = wmi_object.ExecMethod_(method_name, parameter_instance)
+    else:
+        # Execute the method without any parameters.
+        result = wmi_object.ExecMethod_(method_name)
+
+    # Getting Result.
+    # Get the output parameters names that a method returns.
+    if method.OutParameters:
+        out_properties_names = [
+            (out_property.Name, out_property.IsArray) for out_property in method.OutParameters.Properties_]
+    else:
+        out_properties_names = []
+
+    # Get the results for each parameter the method returns.
+    results = []
+    for name, is_array in out_properties_names:
+        value = result.Properties_(name).Value
+        if is_array:
+            results.append(list(value or []))
+        else:
+            results.append(value)
+
+    # Check if the method executed successfully.
+    for result in results:
+        if result != 0:
+            raise WmiMethodExecutionError(f"Failed to execute method '{method_name}' with error code: {result}")
+
+
+"""
+# Setting SeDebugPrivilege
+import win32security, ntsecuritycon, win32con, win32api
+privs = ((win32security.LookupPrivilegeValue('',ntsecuritycon.SE_DEBUG_NAME), win32con.SE_PRIVILEGE_ENABLED),)
+hToken = win32security.OpenProcessToken(win32api.GetCurrentProcess(), win32security.TOKEN_ALL_ACCESS)
+win32security.AdjustTokenPrivileges(hToken, False, privs)
+win32api.CloseHandle(hToken)
+"""