atomicshop 3.3.28__py3-none-any.whl → 3.10.0__py3-none-any.whl

atomicshop/wrappers/factw/install/pre_install_and_install_before_restart.py

@@ -1,13 +1,13 @@
-import sys
 import subprocess
 from pathlib import Path
 
+from dkarchiver.arch_wrappers import zips
+from dkinst.installers.helpers import docker_installer
+
 from .... import filesystem
 from ....permissions import ubuntu_permissions
-from ....archiver import zips
 from ....print_api import print_api
 from ... import githubw, pipw, ubuntu_terminal
-from ...dockerw import install_docker
 from .. import config_install
 
 
@@ -87,7 +87,7 @@ def install_before_restart(
 
         # Install docker. FACT installs the docker, but there can be a problem with permissions, so we need to add
         # the user permissions to the docker group before restart.
-        if not install_docker.add_current_user_to_docker_group():
+        if not docker_installer.add_current_user_to_docker_group():
             print_api("Docker is installed, but the current user was not added to the docker group.", color='red')
             return 1
     else:
@@ -108,7 +108,7 @@ def install_before_restart(
         #     use_docker_installer=True, rootless=True, add_current_user_to_docker_group_bool=False)
 
         # Install docker in regular mode.
-        result: int = install_docker.install_docker_ubuntu(
+        result: int = docker_installer.install_docker_ubuntu(
             use_docker_installer=True, rootless=False, add_current_user_to_docker_group_bool=True)
         if result != 0:
             print_api("Docker installation failed. Please install Docker manually.", color='red')

atomicshop/wrappers/githubw.py

@@ -163,11 +163,103 @@ class GitHubWrapper:
 
         self.build_links_from_user_and_repo()
 
-    def check_github_domain(self, domain):
+    def check_github_domain(
+            self,
+            domain: str
+    ):
         if self.domain not in domain:
             print_api(
                 f'This is not [{self.domain}] domain.', color="red", error_type=True)
 
+    def download_file(
+            self,
+            file_name: str,
+            target_dir: str
+    ) -> str:
+        """
+        Download a single repo file to a local directory.
+
+        :param file_name: string, Full repo-relative path to the file. Example:
+             "eng.traineddata"
+             "script\\English.script"
+        :param target_dir: string, Local directory to save into.
+
+        :return: The local path to the downloaded file.
+        """
+
+        # Normalize to GitHub path format
+        file_path = file_name.replace("\\", "/").strip("/")
+
+        headers = self._get_headers()
+        url = f"{self.contents_url}/{file_path}"
+        params = {"ref": self.branch}
+
+        resp = requests.get(url, headers=headers, params=params)
+        resp.raise_for_status()
+        item = resp.json()
+
+        # Expect a single file object
+        if isinstance(item, list) or item.get("type") != "file":
+            raise ValueError(f"'{file_name}' is not a file in branch '{self.branch}'.")
+
+        download_url = item.get("download_url")
+        if not download_url:
+            raise ValueError(f"Unable to obtain download URL for '{file_name}'.")
+
+        os.makedirs(target_dir, exist_ok=True)
+        local_name = item.get("name") or os.path.basename(file_path)
+
+        from .. import web  # ensure available in your module structure
+        web.download(
+            file_url=download_url,
+            target_directory=target_dir,
+            file_name=local_name,
+            headers=headers,
+        )
+        return os.path.join(target_dir, local_name)
+
+    def download_directory(
+            self,
+            folder_name: str,
+            target_dir: str
+    ) -> None:
+        """
+        Recursively download a repo directory to a local directory.
+
+        :param folder_name: string, Repo-relative directory path to download (e.g., "tests/langs").
+        :param target_dir: string, Local directory to save the folder tree into.
+        """
+        headers = self._get_headers()
+        root_path = folder_name.replace("\\", "/").strip("/")
+
+        def _walk_dir(rel_path: str, local_dir: str) -> None:
+            contents_url = f"{self.contents_url}/{rel_path}" if rel_path else self.contents_url
+            params = {"ref": self.branch}
+
+            response = requests.get(contents_url, headers=headers, params=params)
+            response.raise_for_status()
+            items = response.json()
+
+            # If a file path was passed accidentally, delegate to download_file
+            if isinstance(items, dict) and items.get("type") == "file":
+                self.download_file(rel_path, local_dir)
+                return
+
+            if not isinstance(items, list):
+                raise ValueError(f"Unexpected response shape when listing '{rel_path or '/'}'.")
+
+            os.makedirs(local_dir, exist_ok=True)
+
+            for item in items:
+                name = item["name"]
+                if item["type"] == "file":
+                    self.download_file(f"{rel_path}/{name}" if rel_path else name, local_dir)
+                elif item["type"] == "dir":
+                    _walk_dir(f"{rel_path}/{name}" if rel_path else name, os.path.join(local_dir, name))
+                # ignore symlinks/submodules if present
+
+        _walk_dir(root_path, target_dir)
+
     def download_and_extract_branch(
             self,
             target_directory: str,
@@ -184,7 +276,7 @@ class GitHubWrapper:
         :param archive_remove_first_directory: boolean, available only if 'path' was not specified during the initialization
             Sets if archive extract function will extract the archive
             without first directory in the archive. Check reference in the
-            'archiver.zip.extract_archive_with_zipfile' function.
+            'dkarchiver.arch_wrappers.zips.extract_archive_with_zipfile' function.
         :param download_each_file: bool, available only if 'path' was specified during the initialization of the class.
             Sets if each file will be downloaded separately.
 
@@ -195,48 +287,6 @@ class GitHubWrapper:
         :return:
         """
 
-        def download_file(file_url: str, target_dir: str, file_name: str, current_headers: dict) -> None:
-            os.makedirs(target_dir, exist_ok=True)
-
-            web.download(
-                file_url=file_url,
-                target_directory=target_dir,
-                file_name=file_name,
-                headers=current_headers
-            )
-
-        def download_directory(folder_path: str, target_dir: str, current_headers: dict) -> None:
-            # Construct the API URL for the current folder.
-            contents_url = f"{self.contents_url}/{folder_path}"
-            params = {'ref': self.branch}
-
-            response = requests.get(contents_url, headers=current_headers, params=params)
-            response.raise_for_status()
-
-            # Get the list of items (files and subdirectories) in the folder.
-            items = response.json()
-
-            # Ensure the local target directory exists.
-            os.makedirs(target_dir, exist_ok=True)
-
-            # Process each item.
-            for item in items:
-                local_item_path = os.path.join(target_dir, item['name'])
-                if item['type'] == 'file':
-                    download_file(
-                        file_url=item['download_url'],
-                        target_dir=target_dir,
-                        file_name=item['name'],
-                        current_headers=current_headers
-                    )
-                elif item['type'] == 'dir':
-                    # Recursively download subdirectories.
-                    download_directory(
-                        folder_path=f"{folder_path}/{item['name']}",
-                        target_dir=local_item_path,
-                        current_headers=current_headers
-                    )
-
         headers: dict = self._get_headers()
 
         if not download_each_file:
@@ -275,7 +325,7 @@ class GitHubWrapper:
             else:
                 current_target_directory = os.path.join(target_directory, self.path)
 
-            download_directory(self.path, current_target_directory, headers)
+            self.download_directory(self.path, current_target_directory)
 
     def get_releases_json(
             self,
@@ -436,7 +486,8 @@ class GitHubWrapper:
             target_directory: str,
             asset_pattern: str,
             exclude_string: str = None,
-            **kwargs):
+            **kwargs
+    ) -> str:
         """
         This function will download the latest release from the GitHub repository.
         :param target_directory: str, the target directory to download the file.
@@ -444,7 +495,7 @@ class GitHubWrapper:
         :param exclude_string: str, the string to exclude from the search. No wildcards can be used.
             The 'excluded_string' will be filtered before the 'asset_pattern' entries.
         :param kwargs: dict, the print arguments for the 'print_api' function.
-        :return:
+        :return: str, the downloaded file path.
         """
 
         headers: dict = self._get_headers()
@@ -471,7 +522,7 @@ class GitHubWrapper:
         :param exclude_string: str, the string to exclude from the search. No wildcards can be used.
         :param archive_remove_first_directory: bool, sets if archive extract function will extract the archive
             without first directory in the archive. Check reference in the
-            'archiver.zip.extract_archive_with_zipfile' function.
+            'dkarchiver.arch_wrappers.zips.extract_archive_with_zipfile' function.
         :param kwargs: dict, the print arguments for the 'print_api' function.
         :return:
         """
@@ -530,8 +581,77 @@ class GitHubWrapper:
         commit_message = latest_commit.get("commit", {}).get("message", "")
         return commit_message
 
+    def list_files(
+            self,
+            pattern: str = "*",
+            recursive: bool = True,
+            path: str | None = None,
+    ) -> list[str]:
+        """
+        List files in the repository (or in a specific subfolder).
+
+        :param pattern: Glob-style pattern (e.g., "*.ex*", "*test*.py"). Matching is done
+            against the file's base name (not the full path).
+        :param recursive: If True, include files in all subfolders (returns full repo-relative
+            paths). If False, list only the immediate files in the chosen folder.
+        :param path: Optional subfolder to list from (e.g., "tests/langs"). If omitted,
+            uses self.path if set, otherwise the repo root.
+
+        :return: A list of repo-relative file paths that match the pattern.
+        """
+        headers = self._get_headers()
+        base_path = (path or self.path or "").strip("/")
+
+        if recursive:
+            # Use the Git Trees API to fetch all files in one call, then filter.
+            tree_url = f"{self.api_url}/git/trees/{self.branch}"
+            params = {"recursive": "1"}
+            resp = requests.get(tree_url, headers=headers, params=params)
+            resp.raise_for_status()
+            data = resp.json()
+
+            files = []
+            for entry in data.get("tree", []):
+                if entry.get("type") != "blob":
+                    continue  # only files
+                entry_path = entry.get("path", "")
+                # If a base_path was provided, keep only files under it
+                if base_path and not entry_path.startswith(base_path + "/") and entry_path != base_path:
+                    continue
+                # Match pattern against the *file name* (basename)
+                if fnmatch.fnmatch(os.path.basename(entry_path), pattern):
+                    files.append(entry_path)
+            return files
+
+        else:
+            # Non-recursive: use the Contents API to list a single directory.
+            # If base_path is empty, list the repo root.
+            if base_path:
+                contents_url = f"{self.contents_url}/{base_path}"
+            else:
+                contents_url = self.contents_url
+
+            params = {"ref": self.branch}
+            resp = requests.get(contents_url, headers=headers, params=params)
+            resp.raise_for_status()
+            items = resp.json()
 
-def parse_github_args():
+            # The Contents API returns a dict when the path points to a single file;
+            # normalize to a list to simplify handling.
+            if isinstance(items, dict):
+                items = [items]
+
+            files = []
+            for item in items:
+                if item.get("type") == "file":
+                    name = item.get("name", "")
+                    if fnmatch.fnmatch(name, pattern):
+                        # item["path"] is the full repo-relative path we want to return
+                        files.append(item.get("path", name))
+            return files
+
+
+def _make_parser():
     import argparse
 
     parser = argparse.ArgumentParser(description='GitHub Wrapper')
@@ -562,7 +682,7 @@ def parse_github_args():
         '-db', '--download_branch', action='store_true', default=False,
         help='Sets if the branch will be downloaded. In conjunction with path, only the path will be downloaded.')
 
-    return parser.parse_args()
+    return parser
 
 
 def github_wrapper_main(
@@ -571,8 +691,8 @@ def github_wrapper_main(
         path: str = None,
         target_directory: str = None,
         pat: str = None,
-        get_latest_commit_json: bool = False,
         get_latest_commit_message: bool = False,
+        get_latest_commit_json: bool = False,
         download_branch: bool = False
 ):
     """
@@ -610,15 +730,7 @@ def github_wrapper_main(
 
 
 def github_wrapper_main_with_args():
-    args = parse_github_args()
-
-    return github_wrapper_main(
-        repo_url=args.repo_url,
-        branch=args.branch,
-        path=args.path,
-        target_directory=args.target_directory,
-        pat=args.pat,
-        get_latest_commit_json=args.get_latest_commit_json,
-        get_latest_commit_message=args.get_latest_commit_message,
-        download_branch=args.download_branch
-    )
+    main_parser = _make_parser()
+    args = main_parser.parse_args()
+
+    return github_wrapper_main(**vars(args))

atomicshop/wrappers/loggingw/handlers.py

@@ -15,7 +15,7 @@ from . import loggers, formatters, filters, consts
 from ... import datetimes, filesystem
 
 
-"""
+r"""
 # Not used, only for the reference:
 DEFAULT_DATE_STRING_FORMAT: str = "%Y_%m_%d"
 DEFAULT_DATE_REGEX_PATTERN: str = r"^\d{4}_\d{2}_\d{2}$"

atomicshop/wrappers/loggingw/loggingw.py

@@ -1037,6 +1037,8 @@ class ExceptionCsvLogger(CsvLogger):
             self,
             message: Union[str, Exception] = None,
             custom_csv_string: str = None,
+            custom_exception_attribute: str = None,
+            custom_exception_attribute_placement: Literal['before', 'after'] = 'before',
             stdout: bool = True
     ):
         """
@@ -1050,11 +1052,25 @@ class ExceptionCsvLogger(CsvLogger):
             Meaning, that you need to provide the 'custom_header' during the initialization of the object.
             Off course, you can use as many commas as you need in the 'custom_csv_string': "custom1,custom2,custom3".
             This need to be mirrored in the 'custom_header' as well: "custom1,custom2,custom3".
+        :param custom_exception_attribute: If the 'message' is an Exception, you can provide a custom attribute
+            name to extract from the Exception object and add it to the exception message.
+            For example, if the Exception has an attribute 'engine_name', you can provide it here
+            and the exception message will be appended with the value of that attribute.
+        :param custom_exception_attribute_placement: 'before' or 'after', where to place
+            the custom exception attribute value in the exception message.
         :param stdout: If set to True, the exception will be printed to the console.
         """
 
         if message is None or isinstance(message, Exception):
-            message = tracebacks.get_as_string()
+            custom_attribute: str | None = getattr(message, custom_exception_attribute, None)
+            traceback_string: str = tracebacks.get_as_string()
+            if custom_attribute:
+                if custom_exception_attribute_placement == 'before':
+                    message = f"{custom_exception_attribute}: [{custom_attribute}] | {traceback_string}"
+                else:
+                    message = f"{traceback_string} | {custom_exception_attribute}: [{custom_attribute}]"
+            else:
+                message = traceback_string
 
         if custom_csv_string:
             row_of_cols: list = [datetime.datetime.now(), custom_csv_string, message]

atomicshop/wrappers/netshw.py

@@ -1,6 +1,6 @@
 import subprocess
 import re
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 
 # ── regex helpers ─────────────────────────────────────────────────────────
 IP_PATTERN        = r'(?:\d{1,3}\.){3}\d{1,3}'
@@ -10,7 +10,7 @@ RE_SUBNET         = re.compile(rf'(?P<prefix>{IP_PATTERN}/\d+)\s+\(mask\s+(?P<ma
 RE_IP             = re.compile(IP_PATTERN)
 
 
-def _get_netsh_show_config() -> str:
+def get_netsh_show_config() -> str:
     """Run `netsh interface ipv4 show config` and return the raw text."""
     return subprocess.check_output(
         ["netsh", "interface", "ipv4", "show", "config"],
@@ -18,6 +18,7 @@ def _get_netsh_show_config() -> str:
     )
 
 
+# noinspection PyUnresolvedReferences
 def get_netsh_ipv4() -> List[Dict[str, Any]]:
     """
     Parse *all* data from `netsh interface ipv4 show config`.
@@ -27,7 +28,7 @@ def get_netsh_ipv4() -> List[Dict[str, Any]]:
         default_gateways, gateway_metric, interface_metric,
         dns_mode, dns_servers, wins_mode, wins_servers
     """
-    config_text = _get_netsh_show_config()
+    config_text = get_netsh_show_config()
 
     adapters: List[Dict[str, Any]] = []
     adapter: Dict[str, Any] | None = None
@@ -148,3 +149,123 @@ def get_netsh_ipv4() -> List[Dict[str, Any]]:
     #             ad['wins_mode'] = 'mixed'
 
     return adapters
+
+
+def run_netsh(*args: str) -> subprocess.CompletedProcess:
+    """
+    Run a netsh command and return stdout as text.
+
+    Example:
+        run_netsh("interface", "ipv4", "show", "interfaces")
+    """
+    cmd = ["netsh"] + list(args)
+    result = subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        check=False
+    )
+    return result
+
+
+def enable_dhcp_static_coexistence(interface_name: str) -> subprocess.CompletedProcess:
+    """
+    Enable DHCP + static IP coexistence on an interface.
+
+    Equivalent to:
+        netsh interface ipv4 set interface "Ethernet0" dhcpstaticipcoexistence=enabled
+    """
+    return run_netsh(
+        "interface", "ipv4", "set", "interface",
+        interface_name,
+        "dhcpstaticipcoexistence=enabled"
+    )
+
+
+def disable_dhcp_static_coexistence(interface_name: str) -> subprocess.CompletedProcess:
+    """
+    Disable DHCP + static IP coexistence on an interface (optional).
+
+    Equivalent to:
+        netsh interface ipv4 set interface "Ethernet0" dhcpstaticipcoexistence=disabled
+    """
+    return run_netsh(
+        "interface", "ipv4", "set", "interface",
+        interface_name,
+        "dhcpstaticipcoexistence=disabled"
+    )
+
+
+def add_virtual_ip(
+        interface_name: str,
+        ip: str,
+        mask: str,
+        skip_as_source: bool = True
+) -> subprocess.CompletedProcess:
+    """
+    Add a static 'virtual' IP to a DHCP interface, keeping DHCP intact.
+
+    Equivalent to:
+        netsh interface ipv4 add address "Ethernet0" 192.168.1.201 255.255.255.0 skipassource=true
+
+    Args:
+        interface_name: Interface name, e.g. "Ethernet0"
+        ip:     IP to add, e.g. "192.168.1.201"
+        mask:   Subnet mask, e.g. "255.255.255.0"
+        skip_as_source: If True, adds 'skipassource=true' so Windows does
+                        not prefer this IP as the outbound source address.
+    """
+    args = [
+        "interface", "ipv4", "add", "address",
+        interface_name,
+        ip,
+        mask,
+    ]
+    if skip_as_source:
+        args.append("skipassource=true")
+
+    return run_netsh(*args)
+
+
+def remove_virtual_ip(
+        interface_name: str,
+        ip: str
+) -> subprocess.CompletedProcess:
+    """
+    Remove a previously added virtual IP from the interface.
+
+    Equivalent to:
+        netsh interface ipv4 delete address "Ethernet0" addr=192.168.1.201
+    """
+    return run_netsh(
+        "interface", "ipv4", "delete", "address",
+        interface_name,
+        f"addr={ip}"
+    )
+
+
+def show_interface_config(
+        interface_name: Optional[str] = None
+) -> subprocess.CompletedProcess:
+    """
+    Show IPv4 configuration for all interfaces or a specific one.
+
+    Equivalent to:
+        netsh interface ipv4 show config
+    or:
+        netsh interface ipv4 show config "Ethernet0"
+    """
+    if interface_name:
+        return run_netsh("interface", "ipv4", "show", "config", interface_name)
+    else:
+        return run_netsh("interface", "ipv4", "show", "config")
+
+
+def list_ipv4_interfaces() -> subprocess.CompletedProcess:
+    """
+    List IPv4 interfaces.
+
+    Equivalent to:
+        netsh interface ipv4 show interfaces
+    """
+    return run_netsh("interface", "ipv4", "show", "interfaces")

atomicshop/wrappers/playwrightw/scenarios.py

@@ -219,7 +219,7 @@ def _fetch_content(
     with sync_playwright() as p:
         browser = p.chromium.launch(headless=headless)  # Set headless=True if you don't want to see the browser
 
-        user_agent: str = web.USER_AGENTS['Windows_Chrome_Latest']
+        user_agent: str = web.USER_AGENTS['Chrome 142.0.0 Windows 10/11 x64']
 
         if text_fetch_method == "playwright_copypaste":
             context = browser.new_context(permissions=["clipboard-read", "clipboard-write"], user_agent=user_agent)

atomicshop/wrappers/powershell_networking.py

@@ -0,0 +1,80 @@
+import json
+import subprocess
+from typing import List, Literal
+
+
+def get_interface_ips(
+    interface_name: str,
+    ip_type: Literal["virtual", "dynamic", "all"] = "virtual"
+) -> List[str]:
+    """
+    Return IPv4 addresses on an interface, filtered by 'mode'.
+
+    ip_type:
+      - "virtual": only static/virtual IPs (PrefixOrigin != 'Dhcp')
+      - "dynamic": only DHCP IPs (PrefixOrigin == 'Dhcp')
+      - "all":     all IPv4 IPs on the interface
+
+    If the interface does not exist or has no IPv4 addresses, returns [].
+    """
+
+    ps_script = f"""
+    try {{
+        Get-NetIPAddress -InterfaceAlias "{interface_name}" -AddressFamily IPv4 |
+            Select-Object IPAddress,
+                          @{{
+                              Name = 'PrefixOrigin';
+                              Expression = {{ [string]$_.PrefixOrigin }}
+                           }} |
+            ConvertTo-Json -Depth 3
+    }} catch {{
+        # Return empty JSON array if nothing found / interface missing
+        '[]'
+    }}
+    """
+
+    try:
+        result = subprocess.run(
+            ["powershell", "-NoProfile", "-Command", ps_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+    except subprocess.CalledProcessError as e:
+        # If anything unexpected happens, raise a clearer error
+        msg = (e.stderr or e.stdout or "").strip()
+        raise RuntimeError(f"PowerShell Get-NetIPAddress failed: {msg}") from e
+
+    stdout = result.stdout.strip()
+    if not stdout:
+        return []
+
+    # At this point stdout should be valid JSON (list or single object)
+    data = json.loads(stdout)
+
+    if isinstance(data, dict):
+        data = [data]
+
+    ips: List[str] = []
+    ip_type = ip_type.lower()
+
+    for entry in data:
+        ip = entry.get("IPAddress")
+        origin_raw = entry.get("PrefixOrigin", "")
+        origin = str(origin_raw).lower()
+
+        if not ip:
+            continue
+
+        if ip_type == "virtual":
+            if origin != "dhcp":
+                ips.append(ip)
+        elif ip_type == "dynamic":
+            if origin == "dhcp":
+                ips.append(ip)
+        elif ip_type == "all":
+            ips.append(ip)
+        else:
+            raise ValueError(f"Unsupported mode: {ip_type!r}")
+
+    return ips

atomicshop/wrappers/psutilw/psutil_networks.py

@@ -74,3 +74,12 @@ def get_default_connection_name() -> Union[dict, None]:
                     return {interface: details}
 
     return None
+
+
+def list_network_interfaces() -> list:
+    """
+    Function to list all network interfaces.
+    :return: list of interface names.
+    """
+    iface_names = list(psutil.net_if_addrs().keys())
+    return iface_names