robot-wrapper-sdk 0.2.1__tar.gz → 0.2.5__tar.gz

robot_wrapper_sdk-0.2.5/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: robot-wrapper-sdk
+Version: 0.2.5
+Summary: Robot Platform API SDK
+Author-email: GH Robot Platform Team <team@ghrobot.com>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx[socks]>=0.24.1
+
+# Robot Platform SDK (Python)
+
+Python SDK for Robot Platform with:
+- develop-app authentication (`app_id`/`app_secret`),
+- sync + async clients,
+- auto token refresh,
+- robot operations and login/hardening task flow.
+
+## Installation
+
+```bash
+pip install robot-wrapper-sdk
+```
+
+## Configuration
+
+Set environment variables (recommended):
+
+- `ROBOT_PLATFORM_BASE_URL`
+- `ROBOT_PLATFORM_APP_ID`
+- `ROBOT_PLATFORM_APP_SECRET`
+- `ROBOT_PLATFORM_PROXY_URL` (optional)
+
+Or pass values directly when creating the module.
+
+---
+
+## Quick Start (Sync)
+
+```python
+from robot_sdk import RobotPlatformModule
+
+sdk = RobotPlatformModule(
+    base_url="http://localhost:8085",
+    app_id="your_app_id",
+    app_secret="your_app_secret",
+    # proxy_url="socks5h://192.168.3.100:1080",  # optional
+)
+
+# Read robot
+robot = sdk.get_robot("2047631542552334336")
+print(robot.platform if robot else "not found")
+
+# Update lifecycle status
+sdk.update_status("2047631542552334336", "live")
+
+# Acquire login tasks
+login_tasks = sdk.acquire_need_login(limit=20, lock_minutes=30)
+
+# Update auth status after worker result
+sdk.update_auth_status("2047631542552334336", "authorized")
+# allowed values: authorized | unauthorized | logged_out
+
+# Acquire hardening tasks
+hardening_tasks = sdk.acquire_unhardened(limit=20, lock_minutes=30, min_age_days=0)
+
+# Update hardening status after worker result
+sdk.update_security_hardened("2047631542552334336", True)
+
+sdk.close()
+```
+
+## Quick Start (Async)
+
+```python
+import asyncio
+from robot_sdk import AsyncRobotPlatformModule
+
+async def main():
+    sdk = AsyncRobotPlatformModule(
+        base_url="http://localhost:8085",
+        app_id="your_app_id",
+        app_secret="your_app_secret",
+    )
+
+    robot = await sdk.get_robot("2047631542552334336")
+    print(robot.platform if robot else "not found")
+
+    await sdk.update_auth_status("2047631542552334336", "authorized")
+    await sdk.update_security_hardened("2047631542552334336", True)
+
+    await sdk.close()
+
+asyncio.run(main())
+```
+
+---
+
+## Response Shape (Placeholder)
+
+Acquire endpoints return:
+
+```json
+{
+  "status": "success",
+  "code": 200,
+  "message": "OK",
+  "data": [
+    {
+      "id": "2047631542552334336",
+      "username": "example_user_1",
+      "platform": "facebook",
+      "status": "live",
+      "auth_status": "unauthorized",
+      "metadata": {
+        "security_hardened": false
+      }
+    }
+  ]
+}
+```
+
+Update endpoints return:
+
+```json
+{
+  "status": "success",
+  "code": 200,
+  "message": "OK",
+  "data": null
+}
+```
+
+---
+
+## Main API
+
+### `RobotPlatformModule` (sync)
+- `list_robots(platform=None, status=None, project_id=None, page=1, limit=20)`
+- `get_robot(robot_id)`
+- `delete_robot(robot_id)`
+- `get_secrets(robot_id)`
+- `update_status(robot_id, status)`
+- `acquire_need_login(limit=20, lock_minutes=30)`
+- `acquire_unhardened(limit=20, lock_minutes=30, min_age_days=0)`
+- `update_auth_status(robot_id, auth_status)`
+- `update_security_hardened(robot_id, security_hardened)`
+- `close()`
+
+### `AsyncRobotPlatformModule` (async)
+Async equivalents of all methods above, plus `await close()`.
+
+---
+
+## Documentation
+
+- Usage guide: [`docs/guide.md`](docs/guide.md)
+- Package code: `robot_sdk/`
+
+---
+
+## Build & Publish (Maintainers)
+
+```bash
+make venv
+make install
+make build
+make publish
+```
+
+Requires valid PyPI credentials (Twine).

robot_wrapper_sdk-0.2.5/README.md

@@ -0,0 +1,161 @@
+# Robot Platform SDK (Python)
+
+Python SDK for Robot Platform with:
+- develop-app authentication (`app_id`/`app_secret`),
+- sync + async clients,
+- auto token refresh,
+- robot operations and login/hardening task flow.
+
+## Installation
+
+```bash
+pip install robot-wrapper-sdk
+```
+
+## Configuration
+
+Set environment variables (recommended):
+
+- `ROBOT_PLATFORM_BASE_URL`
+- `ROBOT_PLATFORM_APP_ID`
+- `ROBOT_PLATFORM_APP_SECRET`
+- `ROBOT_PLATFORM_PROXY_URL` (optional)
+
+Or pass values directly when creating the module.
+
+---
+
+## Quick Start (Sync)
+
+```python
+from robot_sdk import RobotPlatformModule
+
+sdk = RobotPlatformModule(
+    base_url="http://localhost:8085",
+    app_id="your_app_id",
+    app_secret="your_app_secret",
+    # proxy_url="socks5h://192.168.3.100:1080",  # optional
+)
+
+# Read robot
+robot = sdk.get_robot("2047631542552334336")
+print(robot.platform if robot else "not found")
+
+# Update lifecycle status
+sdk.update_status("2047631542552334336", "live")
+
+# Acquire login tasks
+login_tasks = sdk.acquire_need_login(limit=20, lock_minutes=30)
+
+# Update auth status after worker result
+sdk.update_auth_status("2047631542552334336", "authorized")
+# allowed values: authorized | unauthorized | logged_out
+
+# Acquire hardening tasks
+hardening_tasks = sdk.acquire_unhardened(limit=20, lock_minutes=30, min_age_days=0)
+
+# Update hardening status after worker result
+sdk.update_security_hardened("2047631542552334336", True)
+
+sdk.close()
+```
+
+## Quick Start (Async)
+
+```python
+import asyncio
+from robot_sdk import AsyncRobotPlatformModule
+
+async def main():
+    sdk = AsyncRobotPlatformModule(
+        base_url="http://localhost:8085",
+        app_id="your_app_id",
+        app_secret="your_app_secret",
+    )
+
+    robot = await sdk.get_robot("2047631542552334336")
+    print(robot.platform if robot else "not found")
+
+    await sdk.update_auth_status("2047631542552334336", "authorized")
+    await sdk.update_security_hardened("2047631542552334336", True)
+
+    await sdk.close()
+
+asyncio.run(main())
+```
+
+---
+
+## Response Shape (Placeholder)
+
+Acquire endpoints return:
+
+```json
+{
+  "status": "success",
+  "code": 200,
+  "message": "OK",
+  "data": [
+    {
+      "id": "2047631542552334336",
+      "username": "example_user_1",
+      "platform": "facebook",
+      "status": "live",
+      "auth_status": "unauthorized",
+      "metadata": {
+        "security_hardened": false
+      }
+    }
+  ]
+}
+```
+
+Update endpoints return:
+
+```json
+{
+  "status": "success",
+  "code": 200,
+  "message": "OK",
+  "data": null
+}
+```
+
+---
+
+## Main API
+
+### `RobotPlatformModule` (sync)
+- `list_robots(platform=None, status=None, project_id=None, page=1, limit=20)`
+- `get_robot(robot_id)`
+- `delete_robot(robot_id)`
+- `get_secrets(robot_id)`
+- `update_status(robot_id, status)`
+- `acquire_need_login(limit=20, lock_minutes=30)`
+- `acquire_unhardened(limit=20, lock_minutes=30, min_age_days=0)`
+- `update_auth_status(robot_id, auth_status)`
+- `update_security_hardened(robot_id, security_hardened)`
+- `close()`
+
+### `AsyncRobotPlatformModule` (async)
+Async equivalents of all methods above, plus `await close()`.
+
+---
+
+## Documentation
+
+- Usage guide: [`docs/guide.md`](docs/guide.md)
+- Package code: `robot_sdk/`
+
+---
+
+## Build & Publish (Maintainers)
+
+```bash
+make venv
+make install
+make build
+make publish
+```
+
+Requires valid PyPI credentials (Twine).

{robot_wrapper_sdk-0.2.1 → robot_wrapper_sdk-0.2.5}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "robot-wrapper-sdk"
-version = "0.2.1"
+version = "0.2.5"
 description = "Robot Platform API SDK"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -16,7 +16,7 @@ authors = [
     { name = "GH Robot Platform Team", email = "team@ghrobot.com" },
 ]
 dependencies = [
-    "httpx>=0.24.1",
+    "httpx[socks]>=0.24.1",
 ]
 
 [project.license]

robot_wrapper_sdk-0.2.5/robot_sdk/__init__.py

@@ -0,0 +1,84 @@
+from typing import Optional, List, Dict, Any, Tuple
+from .infrastructure.api_client import HTTPClient, AsyncHTTPClient
+from .infrastructure.robot_api_repository import RobotAPIRepository, AsyncRobotAPIRepository
+from .application.usecases import RobotUsecase, AsyncRobotUsecase
+from .domain.entities import Robot, RobotSecrets
+
+__version__ = "0.2.1"
+
+class RobotPlatformModule:
+    """Synchronous Facade for the Robot Platform SDK."""
+    def __init__(self, base_url=None, app_id=None, app_secret=None, proxy_url=None):
+        self.client = HTTPClient(base_url, app_id, app_secret, proxy_url)
+        self.repo = RobotAPIRepository(self.client)
+        self.robot_usecase = RobotUsecase(self.repo)
+
+    def close(self):
+        self.client.close()
+
+    def list_robots(self, platform: Optional[str] = None, status: Optional[str] = None, project_id: Optional[int] = None, page: int = 1, limit: int = 20) -> Dict[str, Any]:
+        return self.robot_usecase.list_robots(platform, status, project_id, page, limit)
+
+    def get_robot(self, robot_id: str) -> Optional[Robot]:
+        return self.robot_usecase.get_robot(robot_id)
+
+    def delete_robot(self, robot_id: str) -> None:
+        self.robot_usecase.delete_robot(robot_id)
+
+    def get_secrets(self, robot_id: str) -> Optional[RobotSecrets]:
+        return self.robot_usecase.get_secrets(robot_id)
+
+    def update_status(self, robot_id: str, status: str) -> None:
+        self.robot_usecase.update_status(robot_id, status)
+
+    def acquire_need_login(self, limit: int = 20, lock_minutes: int = 30):
+        return self.robot_usecase.acquire_need_login(limit, lock_minutes)
+
+    def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0):
+        return self.robot_usecase.acquire_unhardened(limit, lock_minutes, min_age_days)
+
+    def update_auth_status(self, robot_id: str, auth_status: str) -> None:
+        self.robot_usecase.update_auth_status(robot_id, auth_status)
+
+    def update_security_hardened(self, robot_id: str, security_hardened: bool) -> None:
+        self.robot_usecase.update_security_hardened(robot_id, security_hardened)
+
+
+class AsyncRobotPlatformModule:
+    """Asynchronous Facade for the Robot Platform SDK."""
+    def __init__(self, base_url=None, app_id=None, app_secret=None, proxy_url=None):
+        self.client = AsyncHTTPClient(base_url, app_id, app_secret, proxy_url)
+        self.repo = AsyncRobotAPIRepository(self.client)
+        self.robot_usecase = AsyncRobotUsecase(self.repo)
+
+    async def close(self):
+        await self.client.close()
+
+    async def list_robots(self, platform: Optional[str] = None, status: Optional[str] = None, project_id: Optional[int] = None, page: int = 1, limit: int = 20) -> Dict[str, Any]:
+        return await self.robot_usecase.list_robots(platform, status, project_id, page, limit)
+
+    async def get_robot(self, robot_id: str) -> Optional[Robot]:
+        return await self.robot_usecase.get_robot(robot_id)
+
+    async def delete_robot(self, robot_id: str) -> None:
+        await self.robot_usecase.delete_robot(robot_id)
+
+    async def get_secrets(self, robot_id: str) -> Optional[RobotSecrets]:
+        return await self.robot_usecase.get_secrets(robot_id)
+
+    async def update_status(self, robot_id: str, status: str) -> None:
+        await self.robot_usecase.update_status(robot_id, status)
+
+    async def acquire_need_login(self, limit: int = 20, lock_minutes: int = 30):
+        return await self.robot_usecase.acquire_need_login(limit, lock_minutes)
+
+    async def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0):
+        return await self.robot_usecase.acquire_unhardened(limit, lock_minutes, min_age_days)
+
+    async def update_auth_status(self, robot_id: str, auth_status: str) -> None:
+        await self.robot_usecase.update_auth_status(robot_id, auth_status)
+
+    async def update_security_hardened(self, robot_id: str, security_hardened: bool) -> None:
+        await self.robot_usecase.update_security_hardened(robot_id, security_hardened)
+
+__all__ = ["RobotPlatformModule", "AsyncRobotPlatformModule", "Robot", "RobotSecrets"]

robot_wrapper_sdk-0.2.5/robot_sdk/application/usecases.py

@@ -0,0 +1,78 @@
+from typing import Optional, List, Tuple, Any, Dict
+from ..domain.repositories import RobotRepository, AsyncRobotRepository
+from ..domain.entities import Robot, RobotSecrets
+
+class RobotUsecase:
+    def __init__(self, repo: RobotRepository):
+        self.repo = repo
+
+    def get_robot(self, robot_id: str) -> Optional[Robot]:
+        return self.repo.find_by_id(robot_id)
+
+    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)
+
+    def update_status(self, robot_id: str, status: str) -> None:
+        self.repo.update_status(robot_id, status)
+
+    def list_robots(self, platform: Optional[str] = None, 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, project_id, page, limit)
+        return {
+            "data": [r.__dict__ for r in items],
+            "total": total,
+            "page": page,
+            "limit": limit
+        }
+
+    def acquire_need_login(self, limit: int = 20, lock_minutes: int = 30) -> List[Robot]:
+        return self.repo.acquire_need_login(limit, lock_minutes)
+
+    def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0) -> List[Robot]:
+        return self.repo.acquire_unhardened(limit, lock_minutes, min_age_days)
+
+    def update_auth_status(self, robot_id: str, auth_status: str) -> None:
+        self.repo.update_auth_status(robot_id, auth_status)
+
+    def update_security_hardened(self, robot_id: str, security_hardened: bool) -> None:
+        self.repo.update_security_hardened(robot_id, security_hardened)
+
+
+class AsyncRobotUsecase:
+    def __init__(self, repo: AsyncRobotRepository):
+        self.repo = repo
+
+    async def get_robot(self, robot_id: str) -> Optional[Robot]:
+        return await self.repo.find_by_id(robot_id)
+
+    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)
+
+    async def update_status(self, robot_id: str, status: str) -> None:
+        await self.repo.update_status(robot_id, status)
+
+    async def list_robots(self, platform: Optional[str] = None, status: Optional[str] = None, project_id: Optional[int] = None, page: int = 1, limit: int = 20) -> Dict[str, Any]:
+        items, total = await self.repo.list_robots(platform, status, project_id, page, limit)
+        return {
+            "data": [r.__dict__ for r in items],
+            "total": total,
+            "page": page,
+            "limit": limit
+        }
+
+    async def acquire_need_login(self, limit: int = 20, lock_minutes: int = 30) -> List[Robot]:
+        return await self.repo.acquire_need_login(limit, lock_minutes)
+
+    async def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0) -> List[Robot]:
+        return await self.repo.acquire_unhardened(limit, lock_minutes, min_age_days)
+
+    async def update_auth_status(self, robot_id: str, auth_status: str) -> None:
+        await self.repo.update_auth_status(robot_id, auth_status)
+
+    async def update_security_hardened(self, robot_id: str, security_hardened: bool) -> None:
+        await self.repo.update_security_hardened(robot_id, security_hardened)

robot_wrapper_sdk-0.2.5/robot_sdk/domain/entities.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass, field
+from typing import Optional, Any, Dict
+
+@dataclass
+class Robot:
+    id: str
+    username: str
+    platform: str
+    status: str
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    project_id: Optional[str] = None
+    primary_environment: Optional[str] = None
+    created_at: Optional[str] = None
+
+@dataclass
+class RobotSecrets:
+    password: str
+    two_fa_secret: str
+
+@dataclass
+class RobotActivity:
+    id: str
+    activity_type: str
+    status: str
+    message: str
+
+@dataclass
+class AcquireNeedLoginRequest:
+    limit: int = 20
+    lock_minutes: int = 30
+
+@dataclass
+class AcquireUnhardenedRequest:
+    limit: int = 20
+    lock_minutes: int = 30
+    min_age_days: int = 0
+
+@dataclass
+class UpdateAuthStatusRequest:
+    auth_status: str
+
+@dataclass
+class UpdateSecurityHardenedRequest:
+    security_hardened: bool
+
+@dataclass
+class StandardResponse:
+    status: str
+    code: int
+    message: str
+    data: Any = None

robot_wrapper_sdk-0.2.5/robot_sdk/domain/repositories.py

@@ -0,0 +1,77 @@
+from abc import ABC, abstractmethod
+from typing import Optional, List, Tuple
+from .entities import Robot, RobotSecrets
+
+class RobotRepository(ABC):
+    @abstractmethod
+    def find_by_id(self, robot_id: str) -> Optional[Robot]:
+        pass
+
+    @abstractmethod
+    def update_status(self, robot_id: str, status: str) -> None:
+        pass
+
+    @abstractmethod
+    def delete_robot(self, robot_id: str) -> None:
+        pass
+
+    @abstractmethod
+    def get_secrets(self, robot_id: str) -> Optional[RobotSecrets]:
+        pass
+
+    @abstractmethod
+    def list_robots(self, platform: Optional[str] = None, status: Optional[str] = None, project_id: Optional[int] = None, page: int = 1, limit: int = 20) -> Tuple[List[Robot], int]:
+        pass
+
+    @abstractmethod
+    def acquire_need_login(self, limit: int = 20, lock_minutes: int = 30) -> List[Robot]:
+        pass
+
+    @abstractmethod
+    def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0) -> List[Robot]:
+        pass
+
+    @abstractmethod
+    def update_auth_status(self, robot_id: str, auth_status: str) -> None:
+        pass
+
+    @abstractmethod
+    def update_security_hardened(self, robot_id: str, security_hardened: bool) -> None:
+        pass
+
+class AsyncRobotRepository(ABC):
+    @abstractmethod
+    async def find_by_id(self, robot_id: str) -> Optional[Robot]:
+        pass
+
+    @abstractmethod
+    async def update_status(self, robot_id: str, status: str) -> None:
+        pass
+
+    @abstractmethod
+    async def delete_robot(self, robot_id: str) -> None:
+        pass
+
+    @abstractmethod
+    async def get_secrets(self, robot_id: str) -> Optional[RobotSecrets]:
+        pass
+
+    @abstractmethod
+    async def list_robots(self, platform: Optional[str] = None, status: Optional[str] = None, project_id: Optional[int] = None, page: int = 1, limit: int = 20) -> Tuple[List[Robot], int]:
+        pass
+
+    @abstractmethod
+    async def acquire_need_login(self, limit: int = 20, lock_minutes: int = 30) -> List[Robot]:
+        pass
+
+    @abstractmethod
+    async def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0) -> List[Robot]:
+        pass
+
+    @abstractmethod
+    async def update_auth_status(self, robot_id: str, auth_status: str) -> None:
+        pass
+
+    @abstractmethod
+    async def update_security_hardened(self, robot_id: str, security_hardened: bool) -> None:
+        pass