olas-operate-middleware 0.14.2__tar.gz → 0.14.3__tar.gz

{olas_operate_middleware-0.14.2 → olas_operate_middleware-0.14.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: olas-operate-middleware
-Version: 0.14.2
+Version: 0.14.3
 Summary: 
 License-File: LICENSE
 Author: David Vilela
@@ -17,11 +17,11 @@ Requires-Dist: deepdiff (>=8.6.1,<9.0.0)
 Requires-Dist: fastapi (==0.110.3)
 Requires-Dist: halo (==0.0.31)
 Requires-Dist: multiaddr (==0.0.9)
-Requires-Dist: open-aea-cli-ipfs (>=2.0.6,<3.0.0)
-Requires-Dist: open-aea-ledger-cosmos (>=2.0.6,<3.0.0)
-Requires-Dist: open-aea-ledger-ethereum (>=2.0.6,<3.0.0)
-Requires-Dist: open-aea-ledger-ethereum-flashbots (>=2.0.6,<3.0.0)
-Requires-Dist: open-autonomy (>=0.21.5,<0.22.0)
+Requires-Dist: open-aea-cli-ipfs (>=2.0.8,<3.0.0)
+Requires-Dist: open-aea-ledger-cosmos (>=2.0.8,<3.0.0)
+Requires-Dist: open-aea-ledger-ethereum (>=2.0.8,<3.0.0)
+Requires-Dist: open-aea-ledger-ethereum-flashbots (>=2.0.8,<3.0.0)
+Requires-Dist: open-autonomy (>=0.21.7,<0.22.0)
 Requires-Dist: psutil (>=5.9.8,<6.0.0)
 Requires-Dist: pyinstaller (>=6.8.0,<7.0.0)
 Requires-Dist: requests-mock (>=1.12.1,<2.0.0)

{olas_operate_middleware-0.14.2 → olas_operate_middleware-0.14.3}/operate/cli.py

@@ -37,7 +37,7 @@ from types import FrameType
 import autonomy.chain.tx
 from aea.helpers.logging import setup_logger
 from clea import group, params, run
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Query, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from typing_extensions import Annotated
@@ -1066,6 +1066,68 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         deployment_json["healthcheck"] = service.get_latest_healthcheck()
         return JSONResponse(content=deployment_json)
 
+    @app.get("/api/v2/service/{service_config_id}/achievements")
+    async def _get_service_achievements(
+        request: Request, include_acknowledged: bool = Query(False)  # noqa: B008
+    ) -> JSONResponse:
+        """Get the service achievements."""
+        service_config_id = request.path_params["service_config_id"]
+
+        if not operate.service_manager().exists(service_config_id=service_config_id):
+            return service_not_found_error(service_config_id=service_config_id)
+
+        service = operate.service_manager().load(service_config_id=service_config_id)
+
+        achievements_json = service.get_achievements_notifications(
+            include_acknowledged=include_acknowledged,
+        )
+
+        return JSONResponse(content=achievements_json)
+
+    @app.post(
+        "/api/v2/service/{service_config_id}/achievement/{achievement_id}/acknowledge"
+    )
+    async def _acknowledge_achievement(request: Request) -> JSONResponse:
+        """Update a service."""
+        if operate.password is None:
+            return USER_NOT_LOGGED_IN_ERROR
+
+        service_config_id = request.path_params["service_config_id"]
+        manager = operate.service_manager()
+
+        if not manager.exists(service_config_id=service_config_id):
+            return service_not_found_error(service_config_id=service_config_id)
+
+        service = operate.service_manager().load(service_config_id=service_config_id)
+
+        achievement_id = request.path_params["achievement_id"]
+
+        try:
+            service.acknowledge_achievement(
+                achievement_id=achievement_id,
+            )
+        except KeyError:
+            return JSONResponse(
+                content={
+                    "error": f"Achievement {achievement_id} does not exist for service {service_config_id}."
+                },
+                status_code=HTTPStatus.NOT_FOUND,
+            )
+        except ValueError:
+            return JSONResponse(
+                content={
+                    "error": f"Achievement {achievement_id} was already acknowledged for service {service_config_id}."
+                },
+                status_code=HTTPStatus.BAD_REQUEST,
+            )
+
+        return JSONResponse(
+            content={
+                "error": None,
+                "message": f"Acknowledged achievement_id {achievement_id} for service {service_config_id} successfully.",
+            }
+        )
+
     @app.get("/api/v2/service/{service_config_id}/agent_performance")
     async def _get_agent_performance(request: Request) -> JSONResponse:
         """Get the service refill requirements."""

{olas_operate_middleware-0.14.2 → olas_operate_middleware-0.14.3}/operate/constants.py

@@ -35,6 +35,7 @@ DEPLOYMENT_JSON = "deployment.json"
 CONFIG_JSON = "config.json"
 USER_JSON = "user.json"
 HEALTHCHECK_JSON = "healthcheck.json"
+ACHIEVEMENTS_NOTIFICATIONS_JSON = "achievements_notifications.json"
 VERSION_FILE = "operate.version"
 SETTINGS_JSON = "settings.json"
 FUNDING_REQUIREMENTS_JSON = "funding_requirements.json"

{olas_operate_middleware-0.14.2 → olas_operate_middleware-0.14.3}/operate/ledger/profiles.py

@@ -102,6 +102,8 @@ STAKING: t.Dict[Chain, t.Dict[str, str]] = {
         "quickstart_beta_mech_marketplace_expert_8": "0x168aED532a0CD8868c22Fc77937Af78b363652B1",
         "quickstart_beta_mech_marketplace_expert_9": "0xdDa9cD214F12e7C2D58E871404A0A3B1177065C8",
         "quickstart_beta_mech_marketplace_expert_10": "0x53a38655B4e659eF4C7F88A26fbF5c67932C7156",
+        "quickstart_beta_mech_marketplace_expert_11": "0x1eaDe40561C61fa7AcC5D816b1FC55a8d9B58519",
+        "quickstart_beta_mech_marketplace_expert_12": "0x99Fe6B5C9980Fc3A44b1Dc32A76Db6aDfcf4c75e",
         "mech_marketplace": "0x998dEFafD094817EF329f6dc79c703f1CF18bC90",
         "marketplace_supply_alpha": "0xCAbD0C941E54147D40644CF7DA7e36d70DF46f44",
         "marketplace_demand_alpha_1": "0x9d6e7aB0B5B48aE5c146936147C639fEf4575231",
@@ -157,6 +159,10 @@ DEFAULT_PRIORITY_MECH = {  # maps mech marketplace address to its default priori
         "0xC05e7412439bD7e91730a6880E18d5D5873F632C",
         2182,
     ),
+    "0x343F2B005cF6D70bA610CD9F1F1927049414B582": (
+        "0x45F25db135E83d7a010b05FFc1202F8473E3ae7D",
+        25,
+    ),
 }
 
 

{olas_operate_middleware-0.14.2 → olas_operate_middleware-0.14.3}/operate/operate_types.py

@@ -34,7 +34,11 @@ from autonomy.chain.config import LedgerType as LedgerTypeOA
 from cryptography.fernet import Fernet
 from typing_extensions import TypedDict
 
-from operate.constants import FERNET_KEY_LENGTH, NO_STAKING_PROGRAM_ID
+from operate.constants import (
+    ACHIEVEMENTS_NOTIFICATIONS_JSON,
+    FERNET_KEY_LENGTH,
+    NO_STAKING_PROGRAM_ID,
+)
 from operate.resource import LocalResource
 from operate.serialization import BigInt, serialize
 
@@ -220,6 +224,30 @@ class OnChainData(LocalResource):
     user_params: OnChainUserParams
 
 
+@dataclass
+class AchievementNotification(LocalResource):
+    """AchievementNotification"""
+
+    achievement_id: str
+    acknowledged: bool
+    acknowledgement_timestamp: int
+
+    @classmethod
+    def from_json(cls, obj: t.Dict) -> "ChainConfig":
+        """Load the chain config."""
+        return super().from_json(obj)  # type: ignore
+
+
+@dataclass
+class AchievementsNotifications(LocalResource):
+    """AchievementsNotifications"""
+
+    path: Path
+    notifications: t.Dict[str, AchievementNotification]
+
+    _file = ACHIEVEMENTS_NOTIFICATIONS_JSON
+
+
 @dataclass
 class ChainConfig(LocalResource):
     """Chain config."""

{olas_operate_middleware-0.14.2 → olas_operate_middleware-0.14.3}/operate/quickstart/run_service.py

@@ -109,6 +109,8 @@ QS_STAKING_PROGRAMS: t.Dict[Chain, t.Dict[str, str]] = {
         "quickstart_beta_mech_marketplace_expert_8": "trader",
         "quickstart_beta_mech_marketplace_expert_9": "trader",
         "quickstart_beta_mech_marketplace_expert_10": "trader",
+        "quickstart_beta_mech_marketplace_expert_11": "trader",
+        "quickstart_beta_mech_marketplace_expert_12": "trader",
         "mech_marketplace": "mech",
         "marketplace_supply_alpha": "mech",
     },

{olas_operate_middleware-0.14.2 → olas_operate_middleware-0.14.3}/operate/resource.py

@@ -65,6 +65,16 @@ class LocalResource:
             kwargs[pname] = deserialize(obj=obj[pname], otype=ptype)
         return cls(**kwargs)
 
+    @classmethod
+    def exists_at(cls, path: Path) -> bool:
+        """Verifies if local resource exists at specified path."""
+        file = (
+            path / cls._file
+            if cls._file is not None and path.name != cls._file
+            else path
+        )
+        return file.exists()
+
     @classmethod
     def load(cls, path: Path) -> "LocalResource":
         """Load local resource."""

{olas_operate_middleware-0.14.2 → olas_operate_middleware-0.14.3}/operate/services/service.py

@@ -80,6 +80,8 @@ from operate.ledger import get_default_ledger_api, get_default_rpc
 from operate.ledger.profiles import WRAPPED_NATIVE_ASSET
 from operate.operate_http.exceptions import NotAllowed
 from operate.operate_types import (
+    AchievementNotification,
+    AchievementsNotifications,
     AgentRelease,
     Chain,
     ChainAmounts,
@@ -1028,13 +1030,107 @@ class Service(LocalResource):
                 if isinstance(data, dict):
                     agent_performance.update(data)
             except (json.JSONDecodeError, OSError) as e:
-                # Keep default values if file is invalid
-                print(
-                    f"Error reading file 'agent_performance.json': {e}"
-                )  # TODO Use logger
+                logger.warning(f"Cannot read file 'agent_performance.json': {e}")
 
         return dict(sorted(agent_performance.items()))
 
+    def _load_achievements_notifications(
+        self,
+    ) -> t.Tuple[AchievementsNotifications, t.Dict[str, t.Any]]:
+        if not AchievementsNotifications.exists_at(self.path):
+            AchievementsNotifications(
+                path=self.path,
+                notifications={},
+            ).store()
+
+        achievements_notifications: AchievementsNotifications = t.cast(
+            AchievementsNotifications, AchievementsNotifications.load(self.path)
+        )
+
+        agent_achievements_json_path = (
+            Path(
+                self.env_variables.get(
+                    AGENT_PERSISTENT_STORAGE_ENV_VAR, {"value": "."}
+                ).get("value", ".")
+            )
+            / "achievements.json"
+        )
+
+        agent_achievements: t.Dict[str, t.Any] = {}
+        if agent_achievements_json_path.exists():
+            try:
+                with open(agent_achievements_json_path, "r", encoding="utf-8") as f:
+                    agent_achievements = json.load(f)
+            except (json.JSONDecodeError, OSError) as e:
+                print(f"Error reading file 'achievements.json': {e}")
+
+            save_changes = False
+            for achievement_id in agent_achievements:
+                if achievement_id not in achievements_notifications.notifications:
+                    achievements_notifications.notifications[achievement_id] = (
+                        AchievementNotification(
+                            achievement_id=achievement_id,
+                            acknowledged=False,
+                            acknowledgement_timestamp=0,
+                        )
+                    )
+                    save_changes = True
+
+            if save_changes:
+                achievements_notifications.store()
+
+        return achievements_notifications, agent_achievements
+
+    def get_achievements_notifications(
+        self, include_acknowledged: bool
+    ) -> t.List[t.Dict]:
+        """Return the achievements notifications"""
+
+        achievements_notifications, agent_achievements = (
+            self._load_achievements_notifications()
+        )
+
+        output: t.Dict[str, t.Dict] = {}
+
+        for (
+            achievement_id,
+            achievement_notification,
+        ) in achievements_notifications.notifications.items():
+            acknowledged = achievement_notification.acknowledged
+            if not acknowledged or (acknowledged and include_acknowledged):
+                if achievement_id in agent_achievements:
+                    output[achievement_id] = achievement_notification.json
+                    output[achievement_id].update(agent_achievements[achievement_id])
+                else:
+                    logger.warning(
+                        f"Achievement {achievement_id} from notifications database is not present in agent achievements file (Corrupted file?)."
+                    )
+
+        return list(output.values())
+
+    def acknowledge_achievement(self, achievement_id: str) -> None:
+        """Acknowledge an achievement id"""
+
+        achievements_notifications, _ = self._load_achievements_notifications()
+
+        if achievement_id not in achievements_notifications.notifications:
+            raise KeyError(
+                f"Achievement {achievement_id} does not exist for service {self.service_config_id}."
+            )
+
+        achievement_notification = achievements_notifications.notifications[
+            achievement_id
+        ]
+
+        if achievement_notification.acknowledged:
+            raise ValueError(
+                f"Achievement {achievement_id} was already acknowledged for service {self.service_config_id}."
+            )
+
+        achievement_notification.acknowledgement_timestamp = int(time.time())
+        achievement_notification.acknowledged = True
+        achievements_notifications.store()
+
     def update(
         self,
         service_template: ServiceTemplate,

{olas_operate_middleware-0.14.2 → olas_operate_middleware-0.14.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "olas-operate-middleware"
-version = "0.14.2"
+version = "0.14.3"
 description = ""
 authors = ["David Vilela <dvilelaf@gmail.com>", "Viraj Patel <vptl185@gmail.com>"]
 readme = "README.md"
@@ -19,11 +19,11 @@ operate = "operate.cli:main"
 
 [tool.poetry.dependencies]
 python = "<3.12,>=3.10"
-open-autonomy = "^0.21.5"
-open-aea-ledger-cosmos = "^2.0.6"
-open-aea-ledger-ethereum = "^2.0.6"
-open-aea-ledger-ethereum-flashbots = "^2.0.6"
-open-aea-cli-ipfs = "^2.0.6"
+open-autonomy = "^0.21.7"
+open-aea-ledger-cosmos = "^2.0.8"
+open-aea-ledger-ethereum = "^2.0.8"
+open-aea-ledger-ethereum-flashbots = "^2.0.8"
+open-aea-cli-ipfs = "^2.0.8"
 clea = "==0.1.0rc4"
 cytoolz = "==0.12.3"
 fastapi = "0.110.3"