olas-operate-middleware 0.6.3__py3-none-any.whl → 0.8.0__py3-none-any.whl

operate/quickstart/run_service.py

@@ -201,9 +201,6 @@ def configure_local_config(
             )
         os.environ[f"{chain.upper()}_LEDGER_RPC"] = config.rpc[chain]
 
-    if config.password_migrated is None:
-        config.password_migrated = False
-
     config.principal_chain = template["home_chain"]
 
     home_chain = Chain.from_string(config.principal_chain)
@@ -389,8 +386,32 @@ def configure_local_config(
     ):
         print_section("Please enter the arguments that will be used by the service.")
 
+    service_manager = operate.service_manager()
+    mech_configs = service_manager.get_mech_configs(
+        chain=config.principal_chain,
+        ledger_api=ledger_api,
+        staking_program_id=config.staking_program_id,
+    )
+
     for env_var_name, env_var_data in template["env_variables"].items():
         if env_var_data["provision_type"] == ServiceEnvProvisionType.USER:
+            # PRIORITY_MECH_ADDRESS and PRIORITY_MECH_SERVICE_ID are given dynamic default values
+            if env_var_name == "PRIORITY_MECH_ADDRESS":
+                env_var_data["value"] = mech_configs.priority_mech_address
+                if (
+                    env_var_name in config.user_provided_args
+                    and env_var_data["value"] != config.user_provided_args[env_var_name]
+                ):
+                    del config.user_provided_args[env_var_name]
+
+            if env_var_name == "PRIORITY_MECH_SERVICE_ID":
+                env_var_data["value"] = mech_configs.priority_mech_service_id
+                if (
+                    env_var_name in config.user_provided_args
+                    and env_var_data["value"] != config.user_provided_args[env_var_name]
+                ):
+                    del config.user_provided_args[env_var_name]
+
             if env_var_name not in config.user_provided_args:
                 print(f"Description: {env_var_data['description']}")
                 if env_var_data["value"]:
@@ -426,7 +447,7 @@ def configure_local_config(
     return config
 
 
-def ask_password_if_needed(operate: "OperateApp", config: QuickstartConfig) -> None:
+def ask_password_if_needed(operate: "OperateApp") -> None:
     """Ask password if needed."""
     if operate.user_account is None:
         print_section("Set up local user account")
@@ -436,8 +457,6 @@ def ask_password_if_needed(operate: "OperateApp", config: QuickstartConfig) -> N
             password=password,
             path=operate._path / "user.json",
         )
-        config.password_migrated = True
-        config.store()
     else:
         _password = None
         while _password is None:
@@ -590,8 +609,8 @@ def _ask_funds_from_requirements(
     return False
 
 
-def ensure_enough_funds(operate: "OperateApp", service: Service) -> None:
-    """Ensure enough funds."""
+def _maybe_create_master_eoa(operate: "OperateApp") -> None:
+    """Maybe create the Master EOA."""
     if not operate.wallet_manager.exists(ledger_type=LedgerType.ETHEREUM):
         print("Creating the Master EOA...")
         wallet, mnemonic = operate.wallet_manager.create(
@@ -606,9 +625,12 @@ def ensure_enough_funds(operate: "OperateApp", service: Service) -> None:
         ask_or_get_from_env(
             "Press enter to continue...", False, "CONTINUE", raise_if_missing=False
         )
-    else:
-        wallet = operate.wallet_manager.load(ledger_type=LedgerType.ETHEREUM)
 
+
+def ensure_enough_funds(operate: "OperateApp", service: Service) -> None:
+    """Ensure enough funds."""
+    _maybe_create_master_eoa(operate)
+    wallet = operate.wallet_manager.load(ledger_type=LedgerType.ETHEREUM)
     manager = operate.service_manager()
 
     backup_owner = None
@@ -647,11 +669,12 @@ def run_service(
 
     operate.service_manager().migrate_service_configs()
     operate.wallet_manager.migrate_wallet_configs()
+    ask_password_if_needed(operate)
+    _maybe_create_master_eoa(operate)
 
     config = configure_local_config(template, operate)
     manager = operate.service_manager()
     service = get_service(manager, template)
-    ask_password_if_needed(operate, config)
 
     # reload manger and config after setting operate.password
     manager = operate.service_manager(skip_dependency_check=skip_dependency_check)

operate/quickstart/terminate_on_chain_service.py

@@ -62,7 +62,7 @@ def terminate_service(operate: "OperateApp", config_path: str) -> None:
         return
 
     config = configure_local_config(template, operate)
-    ask_password_if_needed(operate, config)
+    ask_password_if_needed(operate)
     manager = operate.service_manager()
     service = get_service(manager, template)
     ensure_enough_funds(operate, service)

operate/quickstart/utils.py

@@ -277,7 +277,6 @@ class QuickstartConfig(LocalResource):
 
     path: Path
     rpc: Optional[Dict[str, str]] = None
-    password_migrated: Optional[bool] = None
     staking_program_id: Optional[str] = None
     principal_chain: Optional[str] = None
     user_provided_args: Optional[Dict[str, str]] = None

operate/services/agent_runner.py

@@ -18,116 +18,193 @@
 #
 # -------------------------------------------------------------
 """Source dode to download and run agent from the repos."""
+import hashlib
 import os
 import platform
 import shutil
 import stat
+from dataclasses import dataclass
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import Tuple
 
 import requests
 from aea.configurations.data_types import PublicId
+from aea.helpers.logging import setup_logger
 
 
+@dataclass
+class AgentRelease:
+    """Agent release dataclass."""
+
+    owner: str
+    repo: str
+    release: str
+
+    @property
+    def release_url(self) -> str:
+        """Get release  api url."""
+        return f"https://api.github.com/repos/{self.owner}/{self.repo}/releases/tags/{self.release}"
+
+    def get_url_and_hash(self, asset_name: str) -> tuple[str, str]:
+        """Get download url and asset sha256 hash."""
+        release_data = requests.get(self.release_url).json()
+
+        assets_filtered = [i for i in release_data["assets"] if i["name"] == asset_name]
+        if not assets_filtered:
+            raise ValueError(
+                f"Asset {asset_name} not found in release {self.release_url}"
+            )
+        asset = assets_filtered[0]
+        file_hash = asset["digest"]
+        file_url = asset["browser_download_url"]
+
+        return file_url, file_hash
+
+
+# list of agents releases supported
 AGENTS_SUPPORTED = {
-    "valory": {
-        "trader": "https://github.com/valory-xyz/trader/releases/download/v0.0.101/",
-        "optimus": "https://github.com/valory-xyz/optimus/releases/download/v0.0.101/",
-    },
-    "dvilela": {
-        "memeooorr": "https://github.com/valory-xyz/meme-ooorr-test/releases/download/v0.0.3/"
-    },
+    "valory/trader": AgentRelease(
+        owner="valory-xyz", repo="trader", release="v0.0.101"
+    ),
+    "valory/optimus": AgentRelease(
+        owner="valory-xyz", repo="optimus", release="v0.0.103"
+    ),
+    "dvilela/memeooorr": AgentRelease(
+        owner="valory-xyz", repo="meme-ooorr", release="v0.0.101"
+    ),
 }
 
 
-def get_agent_runner_executable_name() -> str:
-    """Get runner executable name by platform running."""
-    if platform.system() == "Darwin":
-        os_name = "macos"
-    elif platform.system() == "Windows":
-        os_name = "windows"
-    else:
-        raise ValueError("Platform not supported!")
-
-    if platform.machine().lower() in ("x86_64", "amd64"):
-        arch = "x64"
-    elif platform.machine().lower() == "arm64":
-        arch = "arm64"
-        if os_name == "windows":
-            raise ValueError("Windows arm64 is not supported!")
-    else:
-        raise ValueError(f"unsupported arch: {platform.machine()}")
-
-    exec_name = f"agent_runner_{os_name}_{arch}"
-    if platform.system() == "Windows":
-        exec_name += ".exe"
-    return exec_name
-
-
-def parse_agent(public_id_str: str) -> Tuple[str, str]:
-    """Get authorn and name from agent public string id."""
-    public_id = PublicId.from_str(public_id_string=public_id_str)
-    return (public_id.author, public_id.name)
-
-
-def download_file(url: str, save_path: Path) -> None:
-    """Download file of agent runner."""
-    try:
-        # Send a GET request to the URL
-        response = requests.get(url, stream=True)
-        response.raise_for_status()  # Raise an error for bad status codes (4xx or 5xx)
-
-        # Open the file in binary write mode and save the content
-        with open(save_path, "wb") as file:
-            for chunk in response.iter_content(chunk_size=8192):
-                file.write(chunk)
-
-        print(f"File downloaded and saved to {save_path}")
-    except requests.exceptions.RequestException as e:
-        print(f"Error downloading file: {e}")
-        raise
-
-
-def download_agent_runner(
-    target_path: Path, agent_runner_name: str, agent_public_id_str: str
-) -> None:
-    """Download agent runner."""
-    agent_author, agent_name = parse_agent(public_id_str=agent_public_id_str)
-    if agent_author not in AGENTS_SUPPORTED:
-        raise ValueError(f"No agents supported for author {agent_author}")
-    if agent_name not in AGENTS_SUPPORTED[agent_author]:
-        raise ValueError(
-            f"No agent named {agent_name} supported for author {agent_author}"
+class AgentRunnerManager:
+    """Agent Runner Manager."""
+
+    logger = setup_logger(name="operate.agent_runner_manager")
+    AGENTS = AGENTS_SUPPORTED
+
+    @staticmethod
+    def get_agent_runner_executable_name() -> str:
+        """Get runner executable name by platform running."""
+        if platform.system() == "Darwin":
+            os_name = "macos"
+        elif platform.system() == "Windows":
+            os_name = "windows"
+        else:
+            raise ValueError("Platform not supported!")
+
+        if platform.machine().lower() in ("x86_64", "amd64"):
+            arch = "x64"
+        elif platform.machine().lower() == "arm64":
+            arch = "arm64"
+            if os_name == "windows":
+                raise ValueError("Windows arm64 is not supported!")
+        else:
+            raise ValueError(f"unsupported arch: {platform.machine()}")
+
+        exec_name = f"agent_runner_{os_name}_{arch}"
+        if platform.system() == "Windows":
+            exec_name += ".exe"
+        return exec_name
+
+    @staticmethod
+    def parse_agent(public_id_str: str) -> Tuple[str, str]:
+        """Get authorn and name from agent public string id."""
+        public_id = PublicId.from_str(public_id_string=public_id_str)
+        return (public_id.author, public_id.name)
+
+    @classmethod
+    def download_file(cls, url: str, save_path: Path) -> None:
+        """Download file of agent runner."""
+        try:
+            # Send a GET request to the URL
+            response = requests.get(url, stream=True)
+            response.raise_for_status()  # Raise an error for bad status codes (4xx or 5xx)
+
+            # Open the file in binary write mode and save the content
+            with open(save_path, "wb") as file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    file.write(chunk)
+
+            cls.logger.info(f"File downloaded and saved to {save_path}")
+        except requests.exceptions.RequestException as e:
+            cls.logger.error(f"Error downloading file: {e}")
+            raise
+
+    @classmethod
+    def get_agent_release_by_public_id(cls, agent_public_id_str: str) -> AgentRelease:
+        """Get agent release object according to public id."""
+        agent_author, agent_name = cls.parse_agent(public_id_str=agent_public_id_str)
+
+        agent_name = f"{agent_author}/{agent_name}"
+        agent_release = cls.AGENTS.get(agent_name, None)
+        if agent_release is None:
+            raise ValueError(f"{agent_name} is not supported!")
+        return agent_release
+
+    @staticmethod
+    def get_local_file_sha256(path: Path) -> str:
+        """Get local file sha256."""
+        sha256_hash = hashlib.sha256()
+        with open(path, "rb") as f:
+            for byte_block in iter(lambda: f.read(4096), b""):
+                sha256_hash.update(byte_block)
+        return "sha256:" + sha256_hash.hexdigest()
+
+    @classmethod
+    def update_agent_runner(
+        cls, target_path: Path, agent_runner_name: str, agent_release: AgentRelease
+    ) -> None:
+        """Download agent runner."""
+        download_url, remote_file_hash = agent_release.get_url_and_hash(
+            agent_runner_name
         )
-    repo_url = AGENTS_SUPPORTED[agent_author][agent_name]
-    download_url = f"{repo_url}{agent_runner_name}"
-    try:
-        with TemporaryDirectory() as tmp_dir:
-            tmp_file = Path(tmp_dir) / "agent_runner"
-            download_file(download_url, tmp_file)
-            shutil.copy2(tmp_file, target_path)
-            if os.name == "posix":
-                target_path.chmod(target_path.stat().st_mode | stat.S_IEXEC)
-    except Exception:
-        # remove in cae of errors
-        if target_path.exists():
-            target_path.unlink(missing_ok=True)
-        raise
 
+        if target_path.exists():
+            # check sha
+            current_file_hash = cls.get_local_file_sha256(target_path)
+            if remote_file_hash == current_file_hash:
+                cls.logger.info(
+                    "local and remote files hashes are match, nothing to download"
+                )
+                return
+            cls.logger.info(
+                "local and remote files hashes does not  match, go to download"
+            )
+        else:
+            cls.logger.info("local file not found, go to download")
+
+        try:
+            with TemporaryDirectory() as tmp_dir:
+                tmp_file = Path(tmp_dir) / "agent_runner"
+                cls.download_file(download_url, tmp_file)
+                shutil.copy2(tmp_file, target_path)
+                if os.name == "posix":
+                    target_path.chmod(target_path.stat().st_mode | stat.S_IEXEC)
+        except Exception:
+            # remove in caae of errors
+            if target_path.exists():
+                target_path.unlink(missing_ok=True)
+            raise
+
+    @classmethod
+    def get_agent_runner_path(cls, service_dir: Path, agent_public_id_str: str) -> str:
+        """Get path to the agent runner bin palced."""
+        agent_runner_name = cls.get_agent_runner_executable_name()
+        agent_runner_path: Path = service_dir / agent_runner_name
+        agent_release = cls.get_agent_release_by_public_id(
+            agent_public_id_str=agent_public_id_str
+        )
 
-def get_agent_runner_path(service_dir: Path, agent_public_id_str: str) -> str:
-    """Get path to the agent runner bin palced."""
-    agent_runner_name = get_agent_runner_executable_name()
-    agent_runner_path: Path = service_dir / agent_runner_name
-
-    if agent_runner_path.exists():
-        print(f"agent runner {agent_runner_path} already exists. dont download it.")
-    else:
-        print(f"agent runner {agent_runner_path} does not exists. downloading it.")
-        download_agent_runner(
+        cls.update_agent_runner(
             target_path=agent_runner_path,
             agent_runner_name=agent_runner_name,
-            agent_public_id_str=agent_public_id_str,
+            agent_release=agent_release,
         )
-    return str(agent_runner_path)
+        return str(agent_runner_path)
+
+
+def get_agent_runner_path(service_dir: Path, agent_public_id_str: str) -> str:
+    """Get path to the agent runner bin placed."""
+    return AgentRunnerManager.get_agent_runner_path(
+        service_dir=service_dir, agent_public_id_str=agent_public_id_str
+    )

operate/services/manage.py

@@ -36,7 +36,7 @@ from pathlib import Path
 import requests
 from aea.helpers.base import IPFSHash
 from aea.helpers.logging import setup_logger
-from aea_ledger_ethereum import EthereumCrypto
+from aea_ledger_ethereum import EthereumCrypto, LedgerApi
 from autonomy.chain.base import registry_contracts
 from autonomy.chain.config import CHAIN_PROFILES, ChainType
 
@@ -52,7 +52,7 @@ from operate.ledger import PUBLIC_RPCS, get_currency_denom
 from operate.ledger.profiles import (
     CONTRACTS,
     DEFAULT_MASTER_EOA_FUNDS,
-    DEFAULT_MECH_MARKETPLACE_PRIORITY_MECH,
+    DEFAULT_PRIORITY_MECH,
     OLAS,
     STAKING,
     USDC,
@@ -63,6 +63,7 @@ from operate.operate_types import (
     Chain,
     FundingValues,
     LedgerConfig,
+    MechMarketplaceConfig,
     OnChainState,
     ServiceEnvProvisionType,
     ServiceTemplate,
@@ -518,6 +519,103 @@ class ServiceManager:
                 chain=chain,
             )
 
+    def get_mech_configs(
+        self,
+        chain: str,
+        ledger_api: LedgerApi,
+        staking_program_id: str | None = None,
+    ) -> MechMarketplaceConfig:
+        """Get the mech configs."""
+        sftxb = self.get_eth_safe_tx_builder(
+            ledger_config=LedgerConfig(
+                chain=Chain(chain),
+                rpc=ledger_api.api.provider.endpoint_uri,
+            )
+        )
+        staking_contract = get_staking_contract(
+            chain=chain,
+            staking_program_id=staking_program_id,
+        )
+        if staking_contract is None:
+            return MechMarketplaceConfig(
+                use_mech_marketplace=False,
+                mech_marketplace_address=ZERO_ADDRESS,
+                priority_mech_address=ZERO_ADDRESS,
+                priority_mech_service_id=0,
+            )
+
+        target_staking_params = sftxb.get_staking_params(
+            staking_contract=get_staking_contract(
+                chain=chain,
+                staking_program_id=staking_program_id,
+            ),
+        )
+
+        try:
+            # Try if activity checker is a MechActivityChecker contract
+            mech_activity_contract = t.cast(
+                MechActivityContract,
+                MechActivityContract.from_dir(
+                    directory=str(DATA_DIR / "contracts" / "mech_activity")
+                ),
+            )
+
+            priority_mech_address = (
+                mech_activity_contract.get_instance(
+                    ledger_api=ledger_api,
+                    contract_address=target_staking_params["activity_checker"],
+                )
+                .functions.agentMech()
+                .call()
+            )
+            use_mech_marketplace = False
+            mech_marketplace_address = ZERO_ADDRESS
+            priority_mech_service_id = 0
+
+        except Exception:  # pylint: disable=broad-except
+            # Try if activity checker is a RequesterActivityChecker contract
+            try:
+                requester_activity_checker = t.cast(
+                    RequesterActivityCheckerContract,
+                    RequesterActivityCheckerContract.from_dir(
+                        directory=str(
+                            DATA_DIR / "contracts" / "requester_activity_checker"
+                        )
+                    ),
+                )
+
+                mech_marketplace_address = (
+                    requester_activity_checker.get_instance(
+                        ledger_api=ledger_api,
+                        contract_address=target_staking_params["activity_checker"],
+                    )
+                    .functions.mechMarketplace()
+                    .call()
+                )
+
+                use_mech_marketplace = True
+                priority_mech_address, priority_mech_service_id = DEFAULT_PRIORITY_MECH[
+                    mech_marketplace_address
+                ]
+
+            except Exception as e:  # pylint: disable=broad-except
+                self.logger.error(f"{e}: {traceback.format_exc()}")
+                self.logger.warning(
+                    "Cannot determine type of activity checker contract. Using default parameters. "
+                    "NOTE: This will be an exception in the future!"
+                )
+                priority_mech_address = "0x77af31De935740567Cf4fF1986D04B2c964A786a"
+                use_mech_marketplace = False
+                mech_marketplace_address = ZERO_ADDRESS
+                priority_mech_service_id = 0
+
+        return MechMarketplaceConfig(
+            use_mech_marketplace=use_mech_marketplace,
+            mech_marketplace_address=mech_marketplace_address,
+            priority_mech_address=priority_mech_address,
+            priority_mech_service_id=priority_mech_service_id,
+        )
+
     def _deploy_service_onchain_from_safe(  # pylint: disable=too-many-statements,too-many-locals
         self,
         service_config_id: str,
@@ -582,73 +680,29 @@ class ServiceManager:
         # TODO A customized, arbitrary computation mechanism should be devised.
         env_var_to_value = {}
         if chain == service.home_chain:
-            # Try if activity checker is a MechActivityChecker contract
-            try:
-                mech_activity_contract = t.cast(
-                    MechActivityContract,
-                    MechActivityContract.from_dir(
-                        directory=str(DATA_DIR / "contracts" / "mech_activity")
-                    ),
-                )
-
-                agent_mech = (
-                    mech_activity_contract.get_instance(
-                        ledger_api=sftxb.ledger_api,
-                        contract_address=target_staking_params["activity_checker"],
-                    )
-                    .functions.agentMech()
-                    .call()
-                )
-                use_mech_marketplace = False
-                mech_marketplace_address = ZERO_ADDRESS
-                priority_mech_address = ZERO_ADDRESS
-
-            except Exception:  # pylint: disable=broad-except
-                # Try if activity checker is a RequesterActivityChecker contract
-                try:
-                    requester_activity_checker = t.cast(
-                        RequesterActivityCheckerContract,
-                        RequesterActivityCheckerContract.from_dir(
-                            directory=str(
-                                DATA_DIR / "contracts" / "requester_activity_checker"
-                            )
-                        ),
-                    )
-
-                    mech_marketplace_address = (
-                        requester_activity_checker.get_instance(
-                            ledger_api=sftxb.ledger_api,
-                            contract_address=target_staking_params["activity_checker"],
-                        )
-                        .functions.mechMarketplace()
-                        .call()
-                    )
+            mech_configs: MechMarketplaceConfig = self.get_mech_configs(
+                chain=chain,
+                ledger_api=sftxb.ledger_api,
+                staking_program_id=user_params.staking_program_id,
+            )
 
-                    use_mech_marketplace = True
-                    if (
-                        "PRIORITY_MECH_ADDRESS" in service.env_variables
-                        and service.env_variables["PRIORITY_MECH_ADDRESS"][
-                            "provision_type"
-                        ]
-                        == ServiceEnvProvisionType.USER
-                    ):
-                        agent_mech = priority_mech_address = service.env_variables[
-                            "PRIORITY_MECH_ADDRESS"
-                        ]["value"]
-                    else:
-                        agent_mech = (
-                            priority_mech_address
-                        ) = DEFAULT_MECH_MARKETPLACE_PRIORITY_MECH
+            if (
+                "PRIORITY_MECH_ADDRESS" in service.env_variables
+                and service.env_variables["PRIORITY_MECH_ADDRESS"]["provision_type"]
+                == ServiceEnvProvisionType.USER
+            ):
+                mech_configs.priority_mech_address = service.env_variables[
+                    "PRIORITY_MECH_ADDRESS"
+                ]["value"]
 
-                except Exception:  # pylint: disable=broad-except
-                    self.logger.warning(
-                        "Cannot determine type of activity checker contract. Using default parameters. "
-                        "NOTE: This will be an exception in the future!"
-                    )
-                    agent_mech = "0x77af31De935740567Cf4fF1986D04B2c964A786a"  # nosec
-                    use_mech_marketplace = False
-                    mech_marketplace_address = ZERO_ADDRESS
-                    priority_mech_address = ZERO_ADDRESS
+            if (
+                "PRIORITY_MECH_SERVICE_ID" in service.env_variables
+                and service.env_variables["PRIORITY_MECH_SERVICE_ID"]["provision_type"]
+                == ServiceEnvProvisionType.USER
+            ):
+                mech_configs.priority_mech_service_id = service.env_variables[
+                    "PRIORITY_MECH_SERVICE_ID"
+                ]["value"]
 
             env_var_to_value.update(
                 {
@@ -666,10 +720,10 @@ class ServiceManager:
                         "staking_contract"
                     ),
                     "MECH_MARKETPLACE_CONFIG": (
-                        f'{{"mech_marketplace_address":"{mech_marketplace_address}",'
-                        f'"priority_mech_address":"{priority_mech_address}",'
+                        f'{{"mech_marketplace_address":"{mech_configs.mech_marketplace_address}",'
+                        f'"priority_mech_address":"{mech_configs.priority_mech_address}",'
                         f'"priority_mech_staking_instance_address":"0x998dEFafD094817EF329f6dc79c703f1CF18bC90",'
-                        f'"priority_mech_service_id":{service.env_variables.get("PRIORITY_MECH_SERVICE_ID", {"value": 975})["value"]},'
+                        f'"priority_mech_service_id":{mech_configs.priority_mech_service_id},'
                         f'"requester_staking_instance_address":"{target_staking_params.get("staking_contract")}",'
                         f'"response_timeout":300}}'
                     ),
@@ -679,9 +733,9 @@ class ServiceManager:
                     "MECH_ACTIVITY_CHECKER_CONTRACT": target_staking_params.get(
                         "activity_checker"
                     ),
-                    "MECH_CONTRACT_ADDRESS": agent_mech,
+                    "MECH_CONTRACT_ADDRESS": mech_configs.priority_mech_address,
                     "MECH_REQUEST_PRICE": "10000000000000000",
-                    "USE_MECH_MARKETPLACE": use_mech_marketplace,
+                    "USE_MECH_MARKETPLACE": mech_configs.use_mech_marketplace,
                 }
             )