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

atomicshop/wrappers/githubw.py

@@ -21,7 +21,7 @@ class GitHubWrapper:
             user_name: str = None,
             repo_name: str = None,
             repo_url: str = None,
-            branch: str = 'master',
+            branch: str = 'main',
             path: str = None,
             pat: str = None,
             branch_file_extension: Literal[
@@ -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,
@@ -392,12 +442,12 @@ class GitHubWrapper:
     def get_latest_release_url(
             self,
             asset_pattern: str,
-            exclude_pattern: str = None,
+            exclude_string: str = None,
             **kwargs):
         """
         This function will return the latest release url.
         :param asset_pattern: str, the string pattern to search in the latest release. Wildcards can be used.
-        :param exclude_pattern: str, the string to exclude from the search. No wildcards can be used.
+        :param exclude_string: str, the string to exclude from the search. No wildcards can be used.
         :param kwargs: dict, the print arguments for the 'print_api' function.
         :return: str, the latest release url.
         """
@@ -411,9 +461,9 @@ class GitHubWrapper:
             download_urls.append(single_dict['browser_download_url'])
 
         # Exclude urls against 'exclude_string'.
-        if exclude_pattern:
+        if exclude_string:
             for download_url in download_urls:
-                if exclude_pattern in download_url:
+                if exclude_string in download_url:
                     download_urls.remove(download_url)
 
         # Find urls against 'asset_pattern'.
@@ -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
 
-def parse_github_args():
+            params = {"ref": self.branch}
+            resp = requests.get(contents_url, headers=headers, params=params)
+            resp.raise_for_status()
+            items = resp.json()
+
+            # 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/consts.py

@@ -14,7 +14,7 @@ DEFAULT_ROTATING_SUFFIXES_FROM_WHEN: dict = {
 }
 
 
-DEFAULT_STREAM_FORMATTER: str = "%(levelname)s | %(threadName)s | %(name)s | %(message)s"
+DEFAULT_STREAM_FORMATTER: str = "%(asctime)s | %(levelname)s | %(threadName)s | %(name)s | %(message)s"
 DEFAULT_MESSAGE_FORMATTER: str = "%(message)s"
 
 FORMAT_ELEMENT_TO_HEADER: dict = {

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

@@ -2,7 +2,7 @@ import logging
 import os
 from logging import Logger
 from logging.handlers import QueueListener
-from typing import Literal, Union
+from typing import Literal, Union, Callable
 import datetime
 import contextlib
 import threading
@@ -54,7 +54,7 @@ def create_logger(
         formatter_filehandler_use_nanoseconds: bool = True,
         filehandler_rotate_at_rollover_time: bool = True,
         filehandler_rotation_date_format: str = None,
-        filehandler_rotation_callback_namer_function: callable = None,
+        filehandler_rotation_callback_namer_function: Callable = None,
         filehandler_rotation_use_default_namer_function: bool = True,
         when: str = "midnight",
         interval: int = 1,
@@ -646,7 +646,7 @@ def start_queue_listener_in_multiprocessing(
         formatter_filehandler_use_nanoseconds: bool = True,
         filehandler_rotate_at_rollover_time: bool = True,
         filehandler_rotation_date_format: str = None,
-        filehandler_rotation_callback_namer_function: callable = None,
+        filehandler_rotation_callback_namer_function: Callable = None,
         filehandler_rotation_use_default_namer_function: bool = True,
         when: str = "midnight",
         interval: int = 1,
@@ -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/loggingw/reading.py

@@ -2,12 +2,26 @@ import os
 from typing import Literal, Union
 from pathlib import Path
 import datetime
+import re
 
 from ... import filesystem, datetimes
 from ...basics import booleans, list_of_classes
 from ...file_io import csvs
 
 
+def is_string_ends_with_ymd(s: str) -> bool:
+    date_tail_re = re.compile(r'(\d{4}-\d{2}-\d{2})$')
+
+    m = date_tail_re.search(s)
+    if not m:
+        return False
+    try:
+        datetime.datetime.strptime(m.group(1), "%Y-%m-%d")
+        return True
+    except ValueError:
+        return False
+
+
 def get_logs_paths(
         log_file_path: str,
         date_format: str = None,
@@ -65,6 +79,10 @@ def get_logs_paths(
     log_file_name: str = Path(log_file_path).stem
     log_file_extension: str = Path(log_file_path).suffix
 
+    if is_string_ends_with_ymd(log_file_name):
+        raise ValueError(
+            f'The log file name cannot end with a date in the format YYYY-MM-DD: {log_file_name}')
+
     if not log_file_extension and '.' in log_file_name:
         log_file_name, log_file_extension = log_file_name.rsplit('.')
         log_file_extension = f'.{log_file_extension}'

atomicshop/wrappers/mongodbw/mongo_infra.py

@@ -1,17 +1,7 @@
-import os
-from typing import Union
-
 from pymongo import MongoClient
 import pymongo.errors
 
-from ... import filesystem
-
-if os.name == 'nt':
-    from ... import get_process_list
 
-
-WHERE_TO_SEARCH_FOR_MONGODB_EXE: str = 'C:\\Program Files\\MongoDB\\Server\\'
-MONGODB_EXE_NAME: str = 'mongod.exe'
 MONGODB_DEFAULT_URI: str = 'mongodb://localhost:27017/'
 
 
@@ -39,31 +29,3 @@ def test_connection(
         if raise_exception:
             raise MongoDBNoConnectionError(f"Could not connect to the MongoDB server on: ")
         return False
-
-
-def is_service_running() -> bool:
-    """
-    Check if the MongoDB service is running.
-    :return: bool, True if the MongoDB service is running, False otherwise.
-    """
-
-    if os.name == 'nt':
-        current_processes: dict = (
-            get_process_list.GetProcessList(get_method='pywin32', connect_on_init=True).get_processes())
-
-        for pid, process_info in current_processes.items():
-            if MONGODB_EXE_NAME in process_info['name']:
-                return True
-    else:
-        raise NotImplementedError("This function is not implemented for this OS.")
-
-    return False
-
-
-def is_installed() -> Union[str, None]:
-    """
-    Check if MongoDB is installed.
-    :return: string if MongoDB executable is found, None otherwise.
-    """
-
-    return filesystem.find_file(MONGODB_EXE_NAME, WHERE_TO_SEARCH_FOR_MONGODB_EXE)

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)