robot-wrapper-sdk 0.2.22__tar.gz → 0.2.23__tar.gz

{robot_wrapper_sdk-0.2.22 → robot_wrapper_sdk-0.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robot-wrapper-sdk
-Version: 0.2.22
+Version: 0.2.23
 Summary: Robot Platform API SDK
 Author-email: GH Robot Platform Team <team@ghrobot.com>
 License: MIT

{robot_wrapper_sdk-0.2.22 → robot_wrapper_sdk-0.2.23}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "robot-wrapper-sdk"
-version = "0.2.22"
+version = "0.2.23"
 description = "Robot Platform API SDK"
 readme = "README.md"
 requires-python = ">=3.10"

{robot_wrapper_sdk-0.2.22 → robot_wrapper_sdk-0.2.23}/robot_sdk/__init__.py

@@ -1,15 +1,15 @@
 from typing import Any, Dict, List, Optional, Tuple
 
 from .application.usecases import AsyncRobotUsecase, RobotUsecase
-from .domain.entities import (BrowserCapture, BrowserCookies, BrowserHTML,
-                              BrowserSession, BrowserText, Robot,
-                              RobotAuthStatus, RobotSecrets, RobotStatus,
-                              UpdateRobotRequest)
+from .domain.entities import (AcquireRobotsMetadataFilter, BrowserCapture,
+                              BrowserCookies, BrowserHTML, BrowserSession,
+                              BrowserText, Robot, RobotAuthStatus,
+                              RobotSecrets, RobotStatus, UpdateRobotRequest)
 from .infrastructure.api_client import AsyncHTTPClient, HTTPClient
 from .infrastructure.robot_api_repository import (AsyncRobotAPIRepository,
                                                   RobotAPIRepository)
 
-__version__ = "0.2.22"
+__version__ = "0.2.23"
 class RobotPlatformModule:
     """Synchronous Facade for the Robot Platform SDK."""
 
@@ -42,7 +42,7 @@ class RobotPlatformModule:
     def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0, platforms: Optional[List[str]] = None):
         return self.robot_usecase.acquire_unhardened(limit, lock_minutes, min_age_days, platforms)
 
-    def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None):
+    def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: List[AcquireRobotsMetadataFilter] = []):
         return self.robot_usecase.acquire_robots(limit, lock_minutes, project_name, platform, environment, metadata)
 
     def unlock_login_tasks(self, robot_ids: List[str]) -> None:
@@ -118,7 +118,7 @@ class AsyncRobotPlatformModule:
     async def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0, platforms: Optional[List[str]] = None):
         return await self.robot_usecase.acquire_unhardened(limit, lock_minutes, min_age_days, platforms)
 
-    async def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None):
+    async def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: List[AcquireRobotsMetadataFilter] = []):
         return await self.robot_usecase.acquire_robots(limit, lock_minutes, project_name, platform, environment, metadata)
 
     async def unlock_login_tasks(self, robot_ids: List[str]) -> None:

{robot_wrapper_sdk-0.2.22 → robot_wrapper_sdk-0.2.23}/robot_sdk/application/usecases.py

@@ -1,6 +1,12 @@
-from typing import Optional, List, Tuple, Any, Dict
-from ..domain.repositories import RobotRepository, AsyncRobotRepository
-from ..domain.entities import Robot, RobotSecrets, RobotStatus, RobotAuthStatus, BrowserSession, BrowserCookies, BrowserText, BrowserHTML, BrowserCapture, UpdateRobotRequest
+from typing import Any, Dict, List, Optional, Tuple
+
+from ..domain.entities import (AcquireRobotsMetadataFilter, BrowserCapture,
+                               BrowserCookies, BrowserHTML, BrowserSession,
+                               BrowserText, Robot, RobotAuthStatus,
+                               RobotSecrets, RobotStatus, UpdateRobotRequest)
+from ..domain.repositories import AsyncRobotRepository, RobotRepository
+
+
 class RobotUsecase:
     def __init__(self, repo: RobotRepository):
         self.repo = repo
@@ -10,7 +16,7 @@ class RobotUsecase:
 
     def delete_robot(self, robot_id: str) -> None:
         self.repo.delete_robot(robot_id)
-        
+
     def get_secrets(self, robot_id: str) -> Optional[RobotSecrets]:
         return self.repo.get_secrets(robot_id)
 
@@ -18,7 +24,8 @@ class RobotUsecase:
         self.repo.update_status(robot_id, status)
 
     def list_robots(self, platform: Optional[str] = None, status: Optional[str] = None, auth_status: Optional[str] = None, project_id: Optional[int] = None, page: int = 1, limit: int = 20) -> Dict[str, Any]:
-        items, total = self.repo.list_robots(platform, status, auth_status, project_id, page, limit)
+        items, total = self.repo.list_robots(
+            platform, status, auth_status, project_id, page, limit)
         return {
             "data": [r.__dict__ for r in items],
             "total": total,
@@ -32,7 +39,7 @@ class RobotUsecase:
     def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0, platforms: Optional[List[str]] = None) -> List[Robot]:
         return self.repo.acquire_unhardened(limit, lock_minutes, min_age_days, platforms)
 
-    def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> List[Robot]:
+    def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: List[AcquireRobotsMetadataFilter] = []) -> List[Robot]:
         return self.repo.acquire_robots(limit, lock_minutes, project_name, platform, environment, metadata)
 
     def unlock_login_tasks(self, robot_ids: List[str]) -> None:
@@ -84,7 +91,7 @@ class AsyncRobotUsecase:
 
     async def delete_robot(self, robot_id: str) -> None:
         await self.repo.delete_robot(robot_id)
-        
+
     async def get_secrets(self, robot_id: str) -> Optional[RobotSecrets]:
         return await self.repo.get_secrets(robot_id)
 
@@ -106,7 +113,7 @@ class AsyncRobotUsecase:
     async def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0, platforms: Optional[List[str]] = None) -> List[Robot]:
         return await self.repo.acquire_unhardened(limit, lock_minutes, min_age_days, platforms)
 
-    async def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> List[Robot]:
+    async def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: List[AcquireRobotsMetadataFilter] = []) -> List[Robot]:
         return await self.repo.acquire_robots(limit, lock_minutes, project_name, platform, environment, metadata)
 
     async def unlock_login_tasks(self, robot_ids: List[str]) -> None:

{robot_wrapper_sdk-0.2.22 → robot_wrapper_sdk-0.2.23}/robot_sdk/domain/entities.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Optional, Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 
 class RobotStatus(str, Enum):
@@ -79,6 +79,13 @@ class Robot:
     created_at: Optional[str] = None
 
 
+@dataclass
+class AcquireRobotsMetadataFilter:
+    key: str
+    op: str
+    value: Any
+
+
 @dataclass
 class RobotSecrets:
     password: str

{robot_wrapper_sdk-0.2.22 → robot_wrapper_sdk-0.2.23}/robot_sdk/domain/repositories.py

@@ -1,6 +1,12 @@
 from abc import ABC, abstractmethod
-from typing import Optional, List, Tuple
-from .entities import Robot, RobotSecrets, RobotStatus, RobotAuthStatus, BrowserSession, BrowserCookies, BrowserText, BrowserHTML, BrowserCapture, UpdateRobotRequest
+from typing import List, Optional, Tuple
+
+from .entities import (AcquireRobotsMetadataFilter, BrowserCapture,
+                       BrowserCookies, BrowserHTML, BrowserSession,
+                       BrowserText, Robot, RobotAuthStatus, RobotSecrets,
+                       RobotStatus, UpdateRobotRequest)
+
+
 class RobotRepository(ABC):
     @abstractmethod
     def find_by_id(self, robot_id: str) -> Optional[Robot]:
@@ -31,7 +37,7 @@ class RobotRepository(ABC):
         pass
 
     @abstractmethod
-    def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: Optional[dict] = None) -> List[Robot]:
+    def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: List[AcquireRobotsMetadataFilter] = []) -> List[Robot]:
         pass
 
     @abstractmethod
@@ -86,6 +92,7 @@ class RobotRepository(ABC):
     def capture_browser(self, pod_name: str, extra_data: Optional[dict] = None) -> BrowserCapture:
         pass
 
+
 class AsyncRobotRepository(ABC):
     @abstractmethod
     async def find_by_id(self, robot_id: str) -> Optional[Robot]:
@@ -116,7 +123,7 @@ class AsyncRobotRepository(ABC):
         pass
 
     @abstractmethod
-    async def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: Optional[dict] = None) -> List[Robot]:
+    async def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata:  List[AcquireRobotsMetadataFilter] = []) -> List[Robot]:
         pass
 
     @abstractmethod

{robot_wrapper_sdk-0.2.22 → robot_wrapper_sdk-0.2.23}/robot_sdk/infrastructure/robot_api_repository.py

@@ -1,23 +1,16 @@
 from dataclasses import asdict
-from typing import Optional, List, Tuple, Dict, Any
-from .api_client import HTTPClient, AsyncHTTPClient
-from ..domain.repositories import RobotRepository, AsyncRobotRepository
-from ..domain.entities import (
-    Robot,
-    RobotSecrets,
-    RobotStatus,
-    RobotAuthStatus,
-    UpdateRobotRequest,
-    BrowserSession,
-    BrowserCookies,
-    BrowserText,
-    BrowserHTML,
-    BrowserCapture,
-    normalize_robot_status,
-    normalize_robot_auth_status,
-    ensure_valid_worker_robot_status,
-    ensure_valid_worker_robot_auth_status,
-)
+from typing import Any, Dict, List, Optional, Tuple
+
+from ..domain.entities import (AcquireRobotsMetadataFilter, BrowserCapture,
+                               BrowserCookies, BrowserHTML, BrowserSession,
+                               BrowserText, Robot, RobotAuthStatus,
+                               RobotSecrets, RobotStatus, UpdateRobotRequest,
+                               ensure_valid_worker_robot_auth_status,
+                               ensure_valid_worker_robot_status,
+                               normalize_robot_auth_status,
+                               normalize_robot_status)
+from ..domain.repositories import AsyncRobotRepository, RobotRepository
+from .api_client import AsyncHTTPClient, HTTPClient
 
 
 def _extract_list_payload(resp: Dict[str, Any]) -> Tuple[List[Dict[str, Any]], int]:
@@ -145,7 +138,8 @@ def _to_browser_session(resp: Dict[str, Any]) -> BrowserSession:
     if not isinstance(data, dict):
         return BrowserSession(pod_name="", session_id="", status="")
     raw_extra_data = data.get("extra_data")
-    extra_data: Dict[str, Any] = raw_extra_data if isinstance(raw_extra_data, dict) else {}
+    extra_data: Dict[str, Any] = raw_extra_data if isinstance(
+        raw_extra_data, dict) else {}
     return BrowserSession(
         pod_name=str(data.get("pod_name", "")),
         session_id=str(data.get("session_id", "")),
@@ -160,9 +154,11 @@ def _to_browser_cookies(resp: Dict[str, Any]) -> BrowserCookies:
     if not isinstance(data, dict):
         return BrowserCookies(pod_name="", cookie_count=0, cookies=[])
     raw_cookies = data.get("cookies")
-    cookies: List[Dict[str, Any]] = [cookie for cookie in raw_cookies if isinstance(cookie, dict)] if isinstance(raw_cookies, list) else []
+    cookies: List[Dict[str, Any]] = [cookie for cookie in raw_cookies if isinstance(
+        cookie, dict)] if isinstance(raw_cookies, list) else []
     raw_extra_data = data.get("extra_data")
-    extra_data: Dict[str, Any] = raw_extra_data if isinstance(raw_extra_data, dict) else {}
+    extra_data: Dict[str, Any] = raw_extra_data if isinstance(
+        raw_extra_data, dict) else {}
     return BrowserCookies(
         pod_name=str(data.get("pod_name", "")),
         cookie_count=int(data.get("cookie_count", len(cookies)) or 0),
@@ -180,7 +176,7 @@ def _acquire_payload(limit: int, lock_minutes: int, platforms: Optional[List[str
     return payload
 
 
-def _acquire_robots_payload(limit: int, lock_minutes: int, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+def _acquire_robots_payload(limit: int, lock_minutes: int, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: List[AcquireRobotsMetadataFilter] = []) -> Dict[str, Any]:
     payload: Dict[str, Any] = {"limit": limit, "lock_minutes": lock_minutes}
     if project_name:
         payload["project_name"] = project_name
@@ -189,9 +185,10 @@ def _acquire_robots_payload(limit: int, lock_minutes: int, project_name: Optiona
     if environment:
         payload["environment"] = environment
     if metadata:
-        payload["metadata"] = metadata
+        payload["metadata"] = [asdict(m) for m in metadata]
     return payload
 
+
 class RobotAPIRepository(RobotRepository):
     def __init__(self, client: HTTPClient):
         self.client = client
@@ -205,7 +202,8 @@ class RobotAPIRepository(RobotRepository):
     def update_status(self, robot_id: str, status: str | RobotStatus) -> None:
         normalized_status = normalize_robot_status(status)
         ensure_valid_worker_robot_status(normalized_status)
-        self.client.request("PATCH", f"/robots/{robot_id}/status", json={"status": normalized_status})
+        self.client.request(
+            "PATCH", f"/robots/{robot_id}/status", json={"status": normalized_status})
 
     def delete_robot(self, robot_id: str) -> None:
         self.client.request("DELETE", f"/robots/{robot_id}")
@@ -220,10 +218,14 @@ class RobotAPIRepository(RobotRepository):
 
     def list_robots(self, platform: Optional[str] = None, status: Optional[str] = None, auth_status: Optional[str] = None, project_id: Optional[int] = None, page: int = 1, limit: int = 20) -> Tuple[List[Robot], int]:
         params: Dict[str, Any] = {"page": page, "limit": limit}
-        if platform: params["platform"] = platform
-        if status: params["status"] = status
-        if auth_status: params["auth_status"] = auth_status
-        if project_id: params["project_id"] = project_id
+        if platform:
+            params["platform"] = platform
+        if status:
+            params["status"] = status
+        if auth_status:
+            params["auth_status"] = auth_status
+        if project_id:
+            params["project_id"] = project_id
 
         resp = self.client.request("GET", "/robots", params=params)
         data, total = _extract_list_payload(resp)
@@ -242,16 +244,18 @@ class RobotAPIRepository(RobotRepository):
         resp = self.client.request(
             "POST",
             "/robots/security-hardened/acquire",
-            json=_acquire_payload(limit, lock_minutes, platforms, min_age_days),
+            json=_acquire_payload(limit, lock_minutes,
+                                  platforms, min_age_days),
         )
         data = _extract_items(resp)
         return _to_robots(data)
 
-    def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> List[Robot]:
+    def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: List[AcquireRobotsMetadataFilter] = []) -> List[Robot]:
         resp = self.client.request(
             "POST",
             "/robots/acquire",
-            json=_acquire_robots_payload(limit, lock_minutes, project_name, platform, environment, metadata),
+            json=_acquire_robots_payload(
+                limit, lock_minutes, project_name, platform, environment, metadata),
         )
         data = _extract_items(resp)
         return _to_robots(data)
@@ -294,13 +298,15 @@ class RobotAPIRepository(RobotRepository):
         )
 
     def update_robot(self, robot_id: str, payload: UpdateRobotRequest) -> None:
-        self.client.request("PUT", f"/robots/{robot_id}", json=_compact_update_payload(payload))
+        self.client.request(
+            "PUT", f"/robots/{robot_id}", json=_compact_update_payload(payload))
 
     def open_browser(self, robot_id: Optional[str] = None, username: str = "", proxy: str = "", country_code: str = "", extra_data: Optional[Dict[str, Any]] = None) -> BrowserSession:
         resp = self.client.request(
             "POST",
             "/browser/open",
-            json=_browser_open_payload(robot_id, username, proxy, country_code, extra_data),
+            json=_browser_open_payload(
+                robot_id, username, proxy, country_code, extra_data),
         )
         return _to_browser_session(resp)
 
@@ -350,6 +356,7 @@ class RobotAPIRepository(RobotRepository):
         )
         return _to_browser_capture(resp)
 
+
 class AsyncRobotAPIRepository(AsyncRobotRepository):
     def __init__(self, client: AsyncHTTPClient):
         self.client = client
@@ -378,10 +385,14 @@ class AsyncRobotAPIRepository(AsyncRobotRepository):
 
     async def list_robots(self, platform: Optional[str] = None, status: Optional[str] = None, auth_status: Optional[str] = None, project_id: Optional[int] = None, page: int = 1, limit: int = 20) -> Tuple[List[Robot], int]:
         params: Dict[str, Any] = {"page": page, "limit": limit}
-        if platform: params["platform"] = platform
-        if status: params["status"] = status
-        if auth_status: params["auth_status"] = auth_status
-        if project_id: params["project_id"] = project_id
+        if platform:
+            params["platform"] = platform
+        if status:
+            params["status"] = status
+        if auth_status:
+            params["auth_status"] = auth_status
+        if project_id:
+            params["project_id"] = project_id
 
         resp = await self.client.request("GET", "/robots", params=params)
         data, total = _extract_list_payload(resp)
@@ -400,16 +411,18 @@ class AsyncRobotAPIRepository(AsyncRobotRepository):
         resp = await self.client.request(
             "POST",
             "/robots/security-hardened/acquire",
-            json=_acquire_payload(limit, lock_minutes, platforms, min_age_days),
+            json=_acquire_payload(limit, lock_minutes,
+                                  platforms, min_age_days),
         )
         data = _extract_items(resp)
         return _to_robots(data)
 
-    async def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> List[Robot]:
+    async def acquire_robots(self, limit: int = 20, lock_minutes: int = 30, project_name: Optional[str] = None, platform: Optional[str] = None, environment: Optional[str] = None, metadata: List[AcquireRobotsMetadataFilter] = []) -> List[Robot]:
         resp = await self.client.request(
             "POST",
             "/robots/acquire",
-            json=_acquire_robots_payload(limit, lock_minutes, project_name, platform, environment, metadata),
+            json=_acquire_robots_payload(
+                limit, lock_minutes, project_name, platform, environment, metadata),
         )
         data = _extract_items(resp)
         return _to_robots(data)
@@ -458,7 +471,8 @@ class AsyncRobotAPIRepository(AsyncRobotRepository):
         resp = await self.client.request(
             "POST",
             "/browser/open",
-            json=_browser_open_payload(robot_id, username, proxy, country_code, extra_data),
+            json=_browser_open_payload(
+                robot_id, username, proxy, country_code, extra_data),
         )
         return _to_browser_session(resp)
 

robot_wrapper_sdk-0.2.23/robot_sdk/infrastructure/tests.py

@@ -0,0 +1,2 @@
+def test_acquire_robots():
+    assert True

robot_wrapper_sdk-0.2.23/robot_sdk/tests.py

@@ -0,0 +1,24 @@
+from . import RobotPlatformModule
+from .domain.entities import AcquireRobotsMetadataFilter
+
+
+def test_robot_sdk_acquire_robots():
+    base_url = "http://localhost:8085"
+    app_id = "b550c067c9750de1acc08fbd2009e6d9"
+    app_secret = "c3a3b0ab136a4739dc839dcf3e4f6e93b9b176125ec4b2d47170a6b074debc86"
+    sdk = RobotPlatformModule(
+        base_url=base_url,
+        app_id=app_id,
+        app_secret=app_secret
+    )
+    robots = sdk.acquire_robots(
+        limit=20, lock_minutes=30, platform="facebook", environment="chrome", metadata=[
+            AcquireRobotsMetadataFilter(
+                **{"key": "robot_type", "op": "eq", "value": "fastcheck"},
+            ),
+            AcquireRobotsMetadataFilter(
+                **{"key": "country_code", "op": "eq", "value": "VN"}
+            )
+        ])
+    print(len(robots))
+    assert isinstance(robots, list)

{robot_wrapper_sdk-0.2.22 → robot_wrapper_sdk-0.2.23}/robot_wrapper_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robot-wrapper-sdk
-Version: 0.2.22
+Version: 0.2.23
 Summary: Robot Platform API SDK
 Author-email: GH Robot Platform Team <team@ghrobot.com>
 License: MIT

{robot_wrapper_sdk-0.2.22 → robot_wrapper_sdk-0.2.23}/robot_wrapper_sdk.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 pyproject.toml
 examples/main.py
 robot_sdk/__init__.py
+robot_sdk/tests.py
 robot_sdk/application/__init__.py
 robot_sdk/application/usecases.py
 robot_sdk/domain/__init__.py
@@ -10,6 +11,7 @@ robot_sdk/domain/repositories.py
 robot_sdk/infrastructure/__init__.py
 robot_sdk/infrastructure/api_client.py
 robot_sdk/infrastructure/robot_api_repository.py
+robot_sdk/infrastructure/tests.py
 robot_wrapper_sdk.egg-info/PKG-INFO
 robot_wrapper_sdk.egg-info/SOURCES.txt
 robot_wrapper_sdk.egg-info/dependency_links.txt