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

atomicshop/__init__.py

@@ -1,4 +1,4 @@
 """Atomic Basic functions and classes to make developer life easier"""
 
 __author__ = "Den Kras"
-__version__ = '2.15.11'
+__version__ = '3.10.5'

atomicshop/{addons/mains → a_mains}/FACT/update_extract.py

@@ -1,15 +1,16 @@
 import os
 
+from atomicshop import filesystem
 from atomicshop.wrappers.factw.fact_extractor import get_extractor
 from atomicshop.wrappers.factw import config_install
-from atomicshop import permissions, filesystem
+from atomicshop.permissions import ubuntu_permissions
 
 
 def main():
     get_extractor.get_extractor_script()
     fact_extractor_executable_path: str = (
             filesystem.get_working_directory() + os.sep + config_install.FACT_EXTRACTOR_FILE_NAME)
-    permissions.set_executable_permission(fact_extractor_executable_path)
+    ubuntu_permissions.set_executable(fact_extractor_executable_path)
 
 
 if __name__ == '__main__':

atomicshop/a_mains/dns_gateway_setting.py

@@ -0,0 +1,11 @@
+import sys
+
+from atomicshop import dns
+
+
+def main():
+    dns.default_dns_gateway_main()
+
+
+if __name__ == '__main__':
+    sys.exit(main())

atomicshop/a_mains/get_local_tcp_ports.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+import argparse
+import sys
+
+import psutil
+
+
+def _make_parser():
+    parser = argparse.ArgumentParser(
+        description="List all local TCP source ports currently in use that have a command line."
+    )
+
+    parser.add_argument(
+        '-a', '--show-all', action='store_true',
+        help='Show all the TCP ports and not only these that have command line.')
+
+    return parser
+
+
+def main(
+    show_all: bool = False
+) -> int:
+    # Use a set so we only print each port once
+    source_ports = set()
+
+    try:
+        # Get all TCP connections (any state)
+        # If you only want established ones, use: kind='tcp' and filter by c.status
+        connections = psutil.net_connections(kind='tcp')
+    except psutil.AccessDenied:
+        print("Access denied when reading connections. Try running as admin/root.")
+        return 1
+    except Exception as e:
+        print(f"Error getting connections: {e}")
+        return 1
+
+    # Cache whether each PID has a non-empty cmdline to avoid repeated lookups
+    pid_has_cmdline: dict[int, bool] = {}
+
+    for c in connections:
+        # c.laddr is the local (source) address; may be empty for some entries
+        if not c.laddr:
+            continue
+
+        # psutil uses a namedtuple for laddr: (ip, port)
+        try:
+            port = c.laddr.port  # works on modern psutil (namedtuple)
+        except AttributeError:
+            # fallback if it's a plain tuple
+            port = c.laddr[1]
+
+        if not show_all:
+            pid = c.pid
+            if pid is None:
+                # No associated process => treat as "no command line"
+                continue
+
+            if pid not in pid_has_cmdline:
+                try:
+                    proc = psutil.Process(pid)
+                    cmdline = proc.cmdline()
+                    # Non-empty list and at least one non-empty arg
+                    has_cmd = bool(cmdline and any(arg.strip() for arg in cmdline))
+                    pid_has_cmdline[pid] = has_cmd
+                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                    # If we can't read it, treat as no command line
+                    pid_has_cmdline[pid] = False
+
+            if not pid_has_cmdline[pid]:
+                # Skip ports whose owning process has an empty/unavailable cmdline
+                continue
+
+            # Either show_all is True, or the owning process has a non-empty cmdline
+        source_ports.add(port)
+
+    # Print ports sorted for readability
+    for port in sorted(source_ports):
+        print(port)
+
+    return 0
+
+if __name__ == "__main__":
+    arg_parser = _make_parser()
+    args = arg_parser.parse_args()
+    sys.exit(main(**vars(args)))

atomicshop/a_mains/github_wrapper.py

@@ -0,0 +1,11 @@
+import sys
+
+from atomicshop.wrappers import githubw
+
+
+def main():
+    githubw.github_wrapper_main_with_args()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

atomicshop/a_mains/install_ca_certificate.py

@@ -0,0 +1,172 @@
+import sys
+import os
+import tempfile
+import subprocess
+import re
+import base64
+import textwrap
+
+
+def is_ca_installed(issuer_name: str) -> tuple[bool, str]:
+    result = subprocess.run(
+        ['certutil', '-store', 'Root', issuer_name],
+        capture_output=True,
+        text=True,
+    )
+
+    if 'Object was not found' in result.stdout:
+        return False, ''
+
+    if result.returncode == 0:
+        return True, ''
+    else:
+        message: str = (f"stdout: {result.stdout}\n"
+                        f"stderr: {result.stderr}\n")
+        return False, message
+
+
+def remove_ca_certificate(issuer_name: str) -> int:
+    result = subprocess.run(
+        ['certutil', '-delstore', 'Root', issuer_name],
+        capture_output=True,
+        text=True
+    )
+
+    if result.returncode != 0:
+        print(f"Error removing certificate: {result.stderr}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+def install_ca_certificate(certificate_string: str) -> int:
+    pem = certificate_string or ""
+
+    # Extract one or more CERTIFICATE blocks
+    blocks = re.findall(
+        r"-----BEGIN CERTIFICATE-----.*?-----END CERTIFICATE-----",
+        pem,
+        flags=re.DOTALL,
+    )
+    if not blocks:
+        print("Error installing certificate: no PEM CERTIFICATE block found.", file=sys.stderr)
+        return 1
+
+    def normalize_pem(block: str) -> str:
+        m = re.search(
+            r"-----BEGIN CERTIFICATE-----(.*?)-----END CERTIFICATE-----",
+            block,
+            flags=re.DOTALL,
+        )
+        if not m:
+            raise ValueError("Invalid PEM block.")
+
+        # Remove everything except Base64 alphabet and padding
+        b64 = re.sub(r"[^A-Za-z0-9+/=]", "", m.group(1))
+
+        # Strict decode/encode round-trip to ensure it is valid DER
+        der = base64.b64decode(b64, validate=True)
+        b64_clean = base64.b64encode(der).decode("ascii")
+        wrapped = "\r\n".join(textwrap.wrap(b64_clean, 64))
+
+        return (
+            "-----BEGIN CERTIFICATE-----\r\n"
+            + wrapped
+            + "\r\n-----END CERTIFICATE-----\r\n"
+        )
+
+    for block in blocks:
+        tmp_path = None
+        try:
+            normalized = normalize_pem(block)
+
+            with tempfile.NamedTemporaryFile(
+                mode="w",
+                suffix=".cer",
+                delete=False,       # certutil needs a real path on Windows
+                encoding="ascii",
+                newline="",
+            ) as f:
+                f.write(normalized)
+                tmp_path = f.name
+
+            result = subprocess.run(
+                ["certutil", "-f", "-addstore", "Root", tmp_path],
+                text=True,
+                capture_output=True,
+            )
+
+            if result.returncode != 0:
+                # Optional: try to get a more descriptive parse error
+                dump = subprocess.run(
+                    ["certutil", "-dump", tmp_path],
+                    text=True,
+                    capture_output=True,
+                )
+
+                print(
+                    "Error installing certificate:\n"
+                    f"stdout: {result.stdout}\n"
+                    f"stderr: {result.stderr}\n"
+                    "certutil -dump output:\n"
+                    f"{dump.stdout}\n"
+                    f"{dump.stderr}",
+                    file=sys.stderr,
+                )
+                return 1
+
+        except Exception as e:
+            print(f"Error installing certificate: {e}", file=sys.stderr)
+            return 1
+
+        finally:
+            if tmp_path:
+                try:
+                    os.remove(tmp_path)
+                except OSError:
+                    pass
+
+    return 0
+
+
+def main() -> int:
+    if len(sys.argv) < 3:
+        print("Usage: install_ca_certificate.py <Issuer Name> <crt cert string>", file=sys.stderr)
+        return 1
+
+    certificate_string_base64: str = sys.argv[2]
+    certificate_string = base64.b64decode(certificate_string_base64).decode("utf-8")
+    if not "-----BEGIN CERTIFICATE-----" in certificate_string:
+        print("Error: Certificate string must be in PEM format.", file=sys.stderr)
+        print(certificate_string, file=sys.stderr)
+        return 1
+
+    issuer_name: str = sys.argv[1]
+    is_installed, message = is_ca_installed(issuer_name)
+    if not is_installed and message:
+        print(f"Error checking certificate installation: {message}", file=sys.stderr)
+        return 1
+
+    if is_installed:
+        rc: int = remove_ca_certificate(issuer_name)
+        if rc != 0:
+            return rc
+
+    rc: int = install_ca_certificate(certificate_string)
+    if rc != 0:
+        return rc
+
+    is_installed, message = is_ca_installed(issuer_name)
+    if not is_installed and message:
+        print(f"Error checking certificate installation: {message}", file=sys.stderr)
+        return 1
+
+    if not is_installed:
+        print("Error: Certificate installation failed.", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

atomicshop/a_mains/process_from_port.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+Print the command line of the process that owns a given TCP/UDP source port.
+
+Usage:
+    python get_cmdline_from_port.py <port> [kind]
+
+<port> is required (e.g. 54321)
+[kind] is optional: 'tcp', 'udp', or 'inet' (default: 'inet')
+
+Requires: psutil
+
+===========================
+
+In Ubuntu, you can check available TCP connections and processes with:
+    ss -tnpa
+In Windows, you can check available TCP connections and processes with (only PIDs, no command lines):
+    netstat -ano
+"""
+
+import sys
+import shlex
+import psutil
+
+
+def find_cmdline_by_port(
+        port: int,
+        # kind: str = "inet"
+        kind: str = "tcp"
+) -> str | None:
+    """
+    Return the command line (joined string) of the first process whose local
+    port == `port`, for connections of type `kind` ('tcp', 'udp', 'inet', etc).
+
+    'tcp' is much more specific and faster than 'inet' (which includes both TCP and UDP).
+    """
+
+    # Single system-wide call; 'inet' = IPv4 + IPv6 only (no unix sockets)
+    # Use 'tcp' if you know it's TCP only – slightly faster.
+    try:
+        conns = psutil.net_connections(kind=kind)
+    except psutil.Error:
+        return None
+
+    for conn in conns:
+        # Some entries have no local address or PID (e.g. kernel sockets)
+        laddr = conn.laddr
+        if not laddr:
+            continue
+
+        # laddr is a namedtuple (ip, port) for AF_INET / AF_INET6
+        try:
+            local_port = laddr.port
+        except AttributeError:
+            # Older psutil: laddr is a simple tuple (ip, port)
+            if len(laddr) < 2:
+                continue
+            local_port = laddr[1]
+
+        if local_port != port:
+            continue
+
+        pid = conn.pid
+        if pid is None or pid == 0:
+            continue
+
+        try:
+            proc = psutil.Process(pid)
+            cmdline_list = proc.cmdline()
+        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+            continue
+
+        if cmdline_list:
+            result = shlex.join(cmdline_list)
+        else:
+            # Fallback to process name if cmdline missing
+            try:
+                result = proc.name()
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                return None
+
+        # If result is just a PID string, also fallback to name
+        if result.isnumeric():
+            try:
+                result = proc.name()
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                return None
+
+        return result
+
+    return None
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        print("Usage: get_cmdline_from_port.py <port> [kind]", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        port = int(sys.argv[1])
+    except ValueError:
+        print("Port must be an integer", file=sys.stderr)
+        sys.exit(1)
+
+    kind = sys.argv[2] if len(sys.argv) >= 3 else "tcp"
+
+    result = find_cmdline_by_port(port, kind)
+    if result is not None:
+        print(result)
+        sys.exit(0)
+    else:
+        # Print nothing, or a message – up to you.
+        # Empty output is often nicer for scripts that just parse stdout.
+        # print(f"No process found with local port {port}", file=sys.stderr)
+        sys.exit(2)
+
+
+if __name__ == "__main__":
+    main()

atomicshop/a_mains/set_default_dns_gateway.py

@@ -0,0 +1,90 @@
+import sys
+import socket
+from typing import Union
+import ipaddress
+import subprocess
+
+import psutil
+
+
+def is_ip_address(string_value: str) -> bool:
+    try:
+        ipaddress.IPv4Address(string_value)
+        return True
+    except (ipaddress.AddressValueError, ValueError):
+        return False
+
+
+def get_default_internet_ipv4(target: str = "8.8.8.8") -> str:
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+        s.connect((target, 80))  # no packet sent; OS just chooses a route
+        return s.getsockname()[0]  # local address of that route
+
+
+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 = get_default_internet_ipv4()
+
+    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
+
+
+def get_default_interface_name() -> str:
+    default_connection_name_dict: dict = get_default_connection_name()
+    if not default_connection_name_dict:
+        return ""
+    # Get the first key from the dictionary.
+    connection_name: str = list(default_connection_name_dict.keys())[0]
+    return connection_name
+
+
+def set_default_gateway_ipv4(gateway_ipv4: str) -> str | None:
+    interface_name: str = get_default_interface_name()
+    if not interface_name:
+        return "Could not determine the default network interface name."
+
+    # Set the default gateway using 'netsh' command.
+    command: str = f'netsh interface ipv4 set dns name="{interface_name}" static {gateway_ipv4} primary'
+    result = subprocess.run(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    stdout: str = result.stdout.decode().strip()
+    stderr: str = result.stderr.decode().strip()
+
+    if result.returncode != 0:
+        return (f"stdout: {stdout}\n"
+                f"stderr: {stderr}")
+
+    return None
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        print("Usage: set_default_dns_gateway.py <IPv4>", file=sys.stderr)
+        return 1
+
+    dns_ipv4: str = sys.argv[1]
+    if not is_ip_address(dns_ipv4):
+        print("Invalid IPv4 address", file=sys.stderr)
+        return 1
+
+    error_message: str | None = set_default_gateway_ipv4(dns_ipv4)
+    if error_message:
+        print(f"Failed to set default DNS gateway:\n{error_message}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

atomicshop/a_mains/update_config_toml.py

@@ -0,0 +1,38 @@
+import os.path
+import sys
+import argparse
+
+from atomicshop.file_io import tomls
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Update the config.toml file.\n'
+                    'This script will update the current config.toml file with the keys from the target config.toml file.\n'
+                    'If the key is not present in the current config.toml file, it will be added.\n'
+                    'If the key is present in the current config.toml file, its value will be left unchanged.\n')
+    parser.add_argument('current_config_file', type=str, help="Path to the current config.toml file that will be updated.")
+    parser.add_argument('target_config_file', type=str, help="Path to the target config.toml file that we'll get the updates from.")
+    parser.add_argument('-n', '--new_file_path', type=str, help="(OPTIONAL) Path to the new config.toml file that will be created with the updates.", default=None)
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    if os.path.isfile(args.current_config_file) is False:
+        print(f"Error: The current config file '{args.current_config_file}' does not exist.")
+        return 1
+    if os.path.isfile(args.target_config_file) is False:
+        print(f"Error: The target config file '{args.target_config_file}' does not exist.")
+        return 1
+
+    tomls.update_toml_file_with_new_config(
+        main_config_file_path=args.current_config_file,
+        changes_config_file_path=args.target_config_file,
+        new_config_file_path=args.new_file_path)
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

atomicshop/basics/ansi_escape_codes.py

@@ -23,7 +23,8 @@ def get_colors_basic_dict(color):
         'yellow': ColorsBasic.YELLOW,
         'blue': ColorsBasic.BLUE,
         'header': ColorsBasic.HEADER,
-        'cyan': ColorsBasic.CYAN
+        'cyan': ColorsBasic.CYAN,
+        'orange': ColorsBasic.ORANGE
     }
 
     return colors_basic_dict[color]
@@ -48,6 +49,7 @@ class ColorsBasic:
     BLUE = '\033[94m'
     HEADER = '\033[95m'
     CYAN = '\033[96m'
+    ORANGE = '\033[38;2;255;165;0m'
     END = ANSI_END
 
 

atomicshop/basics/argparse_template.py

@@ -36,6 +36,8 @@ class ArgparseWrapper:
         # formatter_class=RawTextHelpFormatter: shows raw text and not the default argparse text parsing.
         self.parser = argparse.ArgumentParser(description=self.description_full,
                                               usage=self.usage_variable,
+                                              # usage=argparse.SUPPRESS         # Remove usage line from the beginning.
+                                              # add_help=False,                 # Remove help line from the end.
                                               formatter_class=RawTextHelpFormatter)
 
     def add_arguments(self) -> None:

atomicshop/basics/booleans.py

@@ -1,38 +1,35 @@
-def check_3_booleans_when_only_1_can_be_true(boolean1: tuple, boolean2: tuple, boolean3: tuple) -> None:
+def is_only_1_true_in_list(
+        booleans_list_of_tuples: list[tuple],
+        raise_if_all_false: bool = True
+) -> None:
     """
-    Example:
-        check_3_booleans_when_only_1_can_be_true(
-            (self.config['section']['default_usage'], 'default_usage'),
-            (self.config['section']['create_usage'], 'create_usage'),
-            (self.config['section']['custom_usage'], 'custom_usage'))
-    :param boolean1: tuple, (value, string name of the setting you want to print to the user to be aware of).
-    :param boolean2: tuple, (value, string name of the setting you want to print to the user to be aware of).
-    :param boolean3: tuple, (value, string name of the setting you want to print to the user to be aware of).
-    :return:
+    Check if only one boolean can be 'True' from a list of booleans
+    :param booleans_list_of_tuples: list of tuples, Structure:
+        [(value, string name of the setting you want to print to the user to be aware of), ...]
+    :param raise_if_all_false: bool, If True, exception will be raised if all booleans are False.
+    :return: None
     """
 
-    check_if_3_booleans_are_false(boolean1, boolean2, boolean3)
-    check_if_2_booleans_are_true(boolean1, boolean2)
-    check_if_2_booleans_are_true(boolean1, boolean3)
-    check_if_2_booleans_are_true(boolean2, boolean3)
+    # Filter to get all the `True` conditions and their associated names
+    true_conditions = [name for value, name in booleans_list_of_tuples if value]
 
+    # Count the number of True values
+    true_count = len(true_conditions)
 
-def check_if_3_booleans_are_false(boolean1: tuple, boolean2: tuple, boolean3: tuple):
-    if not boolean1[0] and not boolean2[0] and not boolean3[0]:
-        message = f"All the boolean settings in config ini file were set to 'False',\n" \
-                  f"You need at least one 'True':\n" \
-                  f"{boolean1[1]}={boolean1[0]}\n" \
-                  f"{boolean2[1]}={boolean2[0]}\n" \
-                  f"{boolean3[1]}={boolean3[0]}"
-        raise ValueError(message)
-
-
-def check_if_2_booleans_are_true(boolean1: tuple, boolean2: tuple) -> None:
-    if boolean1[0] and boolean2[0]:
-        message = f"Only one configuration can be 'True':\n" \
-                  f"{boolean1[1]}={boolean1[0]}\n" \
-                  f"{boolean2[1]}={boolean2[0]}\n"
-        raise ValueError(message)
+    if true_count == 1:
+        # Only one value is True, which is acceptable
+        # print(f"Only one condition is True: {true_conditions[0]}.")
+        pass
+    elif true_count > 1:
+        # More than one value is True, raise an exception
+        raise ValueError(f"Multiple conditions are True: {', '.join(true_conditions)}.")
+    elif true_count == 0 and raise_if_all_false:
+        # None of the values are True, and the user does not want to ignore this case
+        raise ValueError("No conditions are True, and raise_if_all_false is set to True.")
+    else:
+        # If no True values and no_raise_if_all_false is True, just pass silently
+        # print("No conditions are True (but raise_if_all_false is set to False).")
+        pass
 
 
 def convert_string_to_bool(string: str) -> bool: