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

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-test", 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

@@ -52,12 +52,14 @@ 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_ADDRESS,
+    DEFAULT_PRIORITY_MECH_SERVICE_ID,
     OLAS,
     STAKING,
     USDC,
     WRAPPED_NATIVE_ASSET,
     get_staking_contract,
+    get_staking_program_mech_type,
 )
 from operate.operate_types import (
     Chain,
@@ -554,6 +556,10 @@ class ServiceManager:
         self.logger.info(f"Service state: {on_chain_state.name}")
 
         current_staking_program = self._get_current_staking_program(service, chain)
+        staking_program_mech_type = get_staking_program_mech_type(
+            user_params.staking_program_id
+        )
+        self.logger.info(f"{staking_program_mech_type=}")
         fallback_params = dict(  # nosec
             staking_contract=NULL_ADDRESS,
             agent_ids=[user_params.agent_id],
@@ -602,6 +608,9 @@ class ServiceManager:
                 use_mech_marketplace = False
                 mech_marketplace_address = ZERO_ADDRESS
                 priority_mech_address = ZERO_ADDRESS
+                priority_mech_service_id = DEFAULT_PRIORITY_MECH_SERVICE_ID.get(
+                    staking_program_mech_type, 0
+                )
 
             except Exception:  # pylint: disable=broad-except
                 # Try if activity checker is a RequesterActivityChecker contract
@@ -638,17 +647,35 @@ class ServiceManager:
                     else:
                         agent_mech = (
                             priority_mech_address
-                        ) = DEFAULT_MECH_MARKETPLACE_PRIORITY_MECH
+                        ) = DEFAULT_PRIORITY_MECH_ADDRESS[staking_program_mech_type]
+
+                    if (
+                        "PRIORITY_MECH_SERVICE_ID" in service.env_variables
+                        and service.env_variables["PRIORITY_MECH_SERVICE_ID"][
+                            "provision_type"
+                        ]
+                        == ServiceEnvProvisionType.USER
+                    ):
+                        priority_mech_service_id = service.env_variables[
+                            "PRIORITY_MECH_SERVICE_ID"
+                        ]["value"]
+                    else:
+                        priority_mech_service_id = DEFAULT_PRIORITY_MECH_SERVICE_ID.get(
+                            staking_program_mech_type, 0
+                        )
 
                 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
+                    agent_mech = DEFAULT_PRIORITY_MECH_ADDRESS[
+                        staking_program_mech_type
+                    ]
                     use_mech_marketplace = False
                     mech_marketplace_address = ZERO_ADDRESS
                     priority_mech_address = ZERO_ADDRESS
+                    priority_mech_service_id = 0
 
             env_var_to_value.update(
                 {
@@ -669,7 +696,7 @@ class ServiceManager:
                         f'{{"mech_marketplace_address":"{mech_marketplace_address}",'
                         f'"priority_mech_address":"{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":{priority_mech_service_id},'
                         f'"requester_staking_instance_address":"{target_staking_params.get("staking_contract")}",'
                         f'"response_timeout":300}}'
                     ),