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

{robot_wrapper_sdk-0.2.5 → robot_wrapper_sdk-0.2.7}/PKG-INFO

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

robot_wrapper_sdk-0.2.7/examples/main.py

@@ -0,0 +1,80 @@
+import asyncio
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from robot_sdk import RobotPlatformModule, AsyncRobotPlatformModule
+
+
+def setup_environ():
+    # Update theo develop-app auth flow
+    os.environ["ROBOT_PLATFORM_BASE_URL"] = "http://localhost:8085"
+    os.environ["ROBOT_PLATFORM_APP_ID"] = "your_app_id"
+    os.environ["ROBOT_PLATFORM_APP_SECRET"] = "your_app_secret"
+    # os.environ["ROBOT_PLATFORM_PROXY_URL"] = "socks5h://192.168.3.100:1080"
+
+
+def test_sync():
+    print("--- SYNC EXECUTION ---")
+    module = RobotPlatformModule()
+    try:
+        robot_id = "2047631542552334336"
+
+        robot = module.get_robot(robot_id)
+        if robot:
+            print("Robot:", robot.username, robot.platform)
+        else:
+            print("Robot not found")
+
+        login_tasks = module.acquire_need_login(limit=20, lock_minutes=30)
+        print("Acquire login tasks:", len(login_tasks))
+
+        module.update_auth_status(robot_id, "authorized")
+        print("Updated auth_status -> authorized")
+
+        hardening_tasks = module.acquire_unhardened(limit=20, lock_minutes=30, min_age_days=0)
+        print("Acquire hardening tasks:", len(hardening_tasks))
+
+        module.update_security_hardened(robot_id, True)
+        print("Updated security_hardened -> true")
+
+    except Exception as e:
+        print("Sync demo error:", e)
+    finally:
+        module.close()
+
+
+async def test_async():
+    print("--- ASYNC EXECUTION ---")
+    module = AsyncRobotPlatformModule()
+    try:
+        robot_id = "2047631542552334336"
+
+        robot = await module.get_robot(robot_id)
+        if robot:
+            print("Robot:", robot.username, robot.platform)
+        else:
+            print("Robot not found")
+
+        login_tasks = await module.acquire_need_login(limit=20, lock_minutes=30)
+        print("Acquire login tasks:", len(login_tasks))
+
+        await module.update_auth_status(robot_id, "authorized")
+        print("Updated auth_status -> authorized")
+
+        hardening_tasks = await module.acquire_unhardened(limit=20, lock_minutes=30, min_age_days=0)
+        print("Acquire hardening tasks:", len(hardening_tasks))
+
+        await module.update_security_hardened(robot_id, True)
+        print("Updated security_hardened -> true")
+
+    except Exception as e:
+        print("Async demo error:", e)
+    finally:
+        await module.close()
+
+
+if __name__ == "__main__":
+    setup_environ()
+    test_sync()
+    asyncio.run(test_async())

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

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

{robot_wrapper_sdk-0.2.5 → robot_wrapper_sdk-0.2.7}/robot_sdk/infrastructure/api_client.py

@@ -1,6 +1,20 @@
 import httpx
 import os
 from typing import Dict, Any, Optional
+from httpx import RemoteProtocolError
+
+def _extract_tokens(payload: Dict[str, Any]) -> tuple[Optional[str], Optional[str]]:
+    data = payload.get("data") if isinstance(payload, dict) else None
+    if isinstance(data, dict):
+        access_token = data.get("access_token")
+        refresh_token = data.get("refresh_token")
+    else:
+        access_token = payload.get("access_token") if isinstance(payload, dict) else None
+        refresh_token = payload.get("refresh_token") if isinstance(payload, dict) else None
+
+    access_token = str(access_token).strip() if access_token else None
+    refresh_token = str(refresh_token).strip() if refresh_token else None
+    return access_token, refresh_token
 
 class RobotAuth(httpx.Auth):
     def __init__(self, login_func, refresh_func):
@@ -9,11 +23,15 @@ class RobotAuth(httpx.Auth):
 
     def auth_flow(self, request):
         token = self.login_func()
+        if not token:
+            raise RuntimeError("Missing access token. Authenticate first.")
         request.headers["Authorization"] = f"Bearer {token}"
         response = yield request
 
         if response.status_code == 401:
             token = self.refresh_func()
+            if not token:
+                raise RuntimeError("Token refresh failed: empty access token")
             request.headers["Authorization"] = f"Bearer {token}"
             yield request
 
@@ -24,11 +42,15 @@ class AsyncRobotAuth(httpx.Auth):
 
     async def async_auth_flow(self, request):
         token = await self.login_func()
+        if not token:
+            raise RuntimeError("Missing access token. Authenticate first.")
         request.headers["Authorization"] = f"Bearer {token}"
         response = yield request
 
         if response.status_code == 401:
             token = await self.refresh_func()
+            if not token:
+                raise RuntimeError("Token refresh failed: empty access token")
             request.headers["Authorization"] = f"Bearer {token}"
             yield request
 
@@ -56,7 +78,10 @@ class HTTPClient:
     def _get_or_login(self) -> str:
         if not self.access_token:
             self._login()
-        return str(self.access_token) if self.access_token else ""
+        token = str(self.access_token).strip() if self.access_token else ""
+        if not token:
+            raise RuntimeError("Empty access token after login")
+        return token
 
     def _login(self) -> None:
         with httpx.Client(proxy=self.proxy_url) as c:
@@ -67,8 +92,7 @@ class HTTPClient:
         resp.raise_for_status()
         try:
             data = resp.json()
-            self.access_token = data.get("access_token")
-            self.refresh_token = data.get("refresh_token")
+            self.access_token, self.refresh_token = _extract_tokens(data)
         except Exception as e:
             print(f"❌ Failed to parse JSON from _login: {e}")
             print(f"📄 Login Response Content: {resp.text[:500]}")
@@ -78,7 +102,10 @@ class HTTPClient:
         # Developer tokens currently don't use refresh flow in the same way, but keeping structure
         if not self.refresh_token:
             self._login()
-            return str(self.access_token) if self.access_token else ""
+            token = str(self.access_token).strip() if self.access_token else ""
+            if not token:
+                raise RuntimeError("Empty access token after login")
+            return token
             
         with httpx.Client(proxy=self.proxy_url) as c:
             resp = c.post(
@@ -89,22 +116,47 @@ class HTTPClient:
             self._login()
         else:
             data = resp.json()
-            self.access_token = data.get("access_token")
-            self.refresh_token = data.get("refresh_token")
-            
-        return str(self.access_token) if self.access_token else ""
+            self.access_token, self.refresh_token = _extract_tokens(data)
+
+        token = str(self.access_token).strip() if self.access_token else ""
+        if not token:
+            raise RuntimeError("Token refresh failed: empty access token")
+        return token
 
     def request(self, method: str, path: str, **kwargs: Any) -> Dict[str, Any]:
-        # Intelligent path prefixing
         full_path = path
-        if not path.startswith("/api/v1/developer"):
-            # If path doesn't start with /api, add it
+        if path.startswith("/api/"):
+            full_path = path
+        else:
             if not path.startswith("/"):
                 path = f"/{path}"
             full_path = f"/api/v1/developer{path}"
-             
+
         print(f"🚀 Requesting: {self.base_url}{full_path}")
-        resp = self.client.request(method, full_path, **kwargs)
+        last_err: Optional[Exception] = None
+        resp = None
+        for attempt in range(2):
+            try:
+                resp = self.client.request(method, full_path, **kwargs)
+                break
+            except Exception as err:
+                msg = str(err)
+                is_disconnect = isinstance(err, RemoteProtocolError) or "Server disconnected without sending a response" in msg
+                if not is_disconnect or attempt == 1:
+                    raise
+                last_err = err
+                self.client.close()
+                self.client = httpx.Client(
+                    base_url=self.base_url,
+                    auth=RobotAuth(self._get_or_login, self._refresh),
+                    proxy=self.proxy_url,
+                )
+
+        if resp is None:
+            if last_err is not None:
+                raise last_err
+            raise RuntimeError("Request failed without response")
+
         resp.raise_for_status()
         try:
             return dict(resp.json())
@@ -140,7 +192,10 @@ class AsyncHTTPClient:
     async def _get_or_login(self) -> str:
         if not self.access_token:
             await self._login()
-        return str(self.access_token) if self.access_token else ""
+        token = str(self.access_token).strip() if self.access_token else ""
+        if not token:
+            raise RuntimeError("Empty access token after login")
+        return token
 
     async def _login(self) -> None:
         async with httpx.AsyncClient(proxy=self.proxy_url) as c:
@@ -151,8 +206,7 @@ class AsyncHTTPClient:
         resp.raise_for_status()
         try:
             data = resp.json()
-            self.access_token = data.get("access_token")
-            self.refresh_token = data.get("refresh_token")
+            self.access_token, self.refresh_token = _extract_tokens(data)
         except Exception as e:
             print(f"❌ Failed to parse JSON from async _login: {e}")
             print(f"📄 Login Response Content: {resp.text[:500]}")
@@ -161,7 +215,10 @@ class AsyncHTTPClient:
     async def _refresh(self) -> str:
         if not self.refresh_token:
             await self._login()
-            return str(self.access_token) if self.access_token else ""
+            token = str(self.access_token).strip() if self.access_token else ""
+            if not token:
+                raise RuntimeError("Empty access token after login")
+            return token
             
         async with httpx.AsyncClient(proxy=self.proxy_url) as c:
             resp = await c.post(
@@ -172,10 +229,12 @@ class AsyncHTTPClient:
             await self._login()
         else:
             data = resp.json()
-            self.access_token = data.get("access_token")
-            self.refresh_token = data.get("refresh_token")
-            
-        return str(self.access_token) if self.access_token else ""
+            self.access_token, self.refresh_token = _extract_tokens(data)
+
+        token = str(self.access_token).strip() if self.access_token else ""
+        if not token:
+            raise RuntimeError("Token refresh failed: empty access token")
+        return token
 
     async def request(self, method: str, path: str, **kwargs: Any) -> Dict[str, Any]:
         # Intelligent path prefixing

{robot_wrapper_sdk-0.2.5 → robot_wrapper_sdk-0.2.7}/robot_sdk/infrastructure/robot_api_repository.py

@@ -3,6 +3,33 @@ from .api_client import HTTPClient, AsyncHTTPClient
 from ..domain.repositories import RobotRepository, AsyncRobotRepository
 from ..domain.entities import Robot, RobotSecrets
 
+
+def _extract_list_payload(resp: Dict[str, Any]) -> Tuple[List[Dict[str, Any]], int]:
+    container = resp.get("data") if isinstance(resp, dict) else None
+    if isinstance(container, dict):
+        items = container.get("data")
+        total = container.get("total", 0)
+    else:
+        items = container
+        total = resp.get("total", 0) if isinstance(resp, dict) else 0
+
+    if not isinstance(items, list):
+        return [], int(total) if isinstance(total, int) else 0
+
+    mapped = [item for item in items if isinstance(item, dict)]
+    return mapped, int(total) if isinstance(total, int) else 0
+
+
+def _extract_items(resp: Dict[str, Any]) -> List[Dict[str, Any]]:
+    container = resp.get("data") if isinstance(resp, dict) else None
+    if isinstance(container, list):
+        return [item for item in container if isinstance(item, dict)]
+    if isinstance(container, dict):
+        nested = container.get("data")
+        if isinstance(nested, list):
+            return [item for item in nested if isinstance(item, dict)]
+    return []
+
 class RobotAPIRepository(RobotRepository):
     def __init__(self, client: HTTPClient):
         self.client = client
@@ -28,8 +55,7 @@ class RobotAPIRepository(RobotRepository):
         if project_id: params["project_id"] = project_id
 
         resp = self.client.request("GET", "/robots", params=params)
-        data = resp.get("data", [])
-        total = resp.get("total", 0)
+        data, total = _extract_list_payload(resp)
         return [Robot(**r) for r in data], total
 
     def acquire_need_login(self, limit: int = 20, lock_minutes: int = 30) -> List[Robot]:
@@ -38,7 +64,7 @@ class RobotAPIRepository(RobotRepository):
             "/robots/login/acquire",
             json={"limit": limit, "lock_minutes": lock_minutes},
         )
-        data = resp.get("data", [])
+        data = _extract_items(resp)
         return [Robot(**r) for r in data]
 
     def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0) -> List[Robot]:
@@ -47,7 +73,7 @@ class RobotAPIRepository(RobotRepository):
             "/robots/security-hardened/acquire",
             json={"limit": limit, "lock_minutes": lock_minutes, "min_age_days": min_age_days},
         )
-        data = resp.get("data", [])
+        data = _extract_items(resp)
         return [Robot(**r) for r in data]
 
     def update_auth_status(self, robot_id: str, auth_status: str) -> None:
@@ -89,8 +115,7 @@ class AsyncRobotAPIRepository(AsyncRobotRepository):
         if project_id: params["project_id"] = project_id
 
         resp = await self.client.request("GET", "/robots", params=params)
-        data = resp.get("data", [])
-        total = resp.get("total", 0)
+        data, total = _extract_list_payload(resp)
         return [Robot(**r) for r in data], total
 
     async def acquire_need_login(self, limit: int = 20, lock_minutes: int = 30) -> List[Robot]:
@@ -99,7 +124,7 @@ class AsyncRobotAPIRepository(AsyncRobotRepository):
             "/robots/login/acquire",
             json={"limit": limit, "lock_minutes": lock_minutes},
         )
-        data = resp.get("data", [])
+        data = _extract_items(resp)
         return [Robot(**r) for r in data]
 
     async def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0) -> List[Robot]:
@@ -108,7 +133,7 @@ class AsyncRobotAPIRepository(AsyncRobotRepository):
             "/robots/security-hardened/acquire",
             json={"limit": limit, "lock_minutes": lock_minutes, "min_age_days": min_age_days},
         )
-        data = resp.get("data", [])
+        data = _extract_items(resp)
         return [Robot(**r) for r in data]
 
     async def update_auth_status(self, robot_id: str, auth_status: str) -> None:

{robot_wrapper_sdk-0.2.5 → robot_wrapper_sdk-0.2.7}/robot_wrapper_sdk.egg-info/PKG-INFO

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

robot_wrapper_sdk-0.2.5/examples/main.py

@@ -1,42 +0,0 @@
-import asyncio
-import os
-import sys
-
-# Mở rộng đường dẫn tránh lỗi module khi chạy local
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
-from robot_sdk import RobotPlatformModule, AsyncRobotPlatformModule
-
-def setup_environ():
-    os.environ["ROBOT_PLATFORM_BASE_URL"] = "http://localhost:8080"
-    os.environ["ROBOT_PLATFORM_USERNAME"] = "testuser"
-    os.environ["ROBOT_PLATFORM_PASSWORD"] = "testpass"
-
-def test_sync():
-    """Ví dụ sử dụng thư viện đồng bộ."""
-    print("--- SYNC EXECUTION ---")
-    module = RobotPlatformModule()
-    try:
-        robot = module.robot_usecase.get_robot_profile("1234")
-        print("Tải thông tin thành công:", robot.username)
-    except Exception as e:
-        print("Lỗi Demo:", e)
-    finally:
-        module.close()
-
-async def test_async():
-    """Ví dụ sử dụng thư viện bất đồng bộ."""
-    print("--- ASYNC EXECUTION ---")
-    module = AsyncRobotPlatformModule()
-    try:
-        robot = await module.robot_usecase.get_robot_profile("1234")
-        print("Tải thông tin thành công:", robot.username)
-    except Exception as e:
-        print("Lỗi Demo:", e)
-    finally:
-        await module.close()
-
-if __name__ == "__main__":
-    setup_environ()
-    
-    test_sync()
-    asyncio.run(test_async())