robot-wrapper-sdk 0.2.9__tar.gz → 0.2.11__tar.gz

{robot_wrapper_sdk-0.2.9 → robot_wrapper_sdk-0.2.11}/PKG-INFO

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

{robot_wrapper_sdk-0.2.9 → robot_wrapper_sdk-0.2.11}/pyproject.toml

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

{robot_wrapper_sdk-0.2.9 → robot_wrapper_sdk-0.2.11}/robot_sdk/domain/entities.py

@@ -32,13 +32,15 @@ def normalize_robot_auth_status(status: str | RobotAuthStatus) -> str:
 def ensure_valid_robot_status(status: str) -> None:
     allowed = {s.value for s in RobotStatus}
     if status not in allowed:
-        raise ValueError(f"invalid status: {status}. allowed={sorted(allowed)}")
+        raise ValueError(
+            f"invalid status: {status}. allowed={sorted(allowed)}")
 
 
 def ensure_valid_robot_auth_status(status: str) -> None:
     allowed = {s.value for s in RobotAuthStatus}
     if status not in allowed:
-        raise ValueError(f"invalid auth_status: {status}. allowed={sorted(allowed)}")
+        raise ValueError(
+            f"invalid auth_status: {status}. allowed={sorted(allowed)}")
 
 
 def ensure_valid_worker_robot_auth_status(status: str) -> None:
@@ -70,16 +72,19 @@ class Robot:
     username: str
     platform: str
     status: str
+    auth_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
@@ -87,25 +92,30 @@ class RobotActivity:
     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

{robot_wrapper_sdk-0.2.9 → robot_wrapper_sdk-0.2.11}/robot_sdk/infrastructure/api_client.py

@@ -3,14 +3,71 @@ import os
 from typing import Dict, Any, Optional
 from httpx import RemoteProtocolError
 
+
+def _build_httpx_client(base_url: str, auth: httpx.Auth, proxy_url: Optional[str]) -> httpx.Client:
+    kwargs: Dict[str, Any] = {"base_url": base_url, "auth": auth}
+    if proxy_url:
+        kwargs["proxy"] = proxy_url
+    try:
+        return httpx.Client(**kwargs)
+    except TypeError:
+        if "proxy" in kwargs:
+            kwargs["proxies"] = kwargs.pop("proxy")
+        return httpx.Client(**kwargs)
+
+
+def _build_async_httpx_client(base_url: str, auth: httpx.Auth, proxy_url: Optional[str]) -> httpx.AsyncClient:
+    kwargs: Dict[str, Any] = {"base_url": base_url, "auth": auth}
+    if proxy_url:
+        kwargs["proxy"] = proxy_url
+    try:
+        return httpx.AsyncClient(**kwargs)
+    except TypeError:
+        if "proxy" in kwargs:
+            kwargs["proxies"] = kwargs.pop("proxy")
+        return httpx.AsyncClient(**kwargs)
+
+
+def _build_plain_httpx_client(proxy_url: Optional[str]) -> httpx.Client:
+    kwargs: Dict[str, Any] = {}
+    if proxy_url:
+        kwargs["proxy"] = proxy_url
+    try:
+        return httpx.Client(**kwargs)
+    except TypeError:
+        if "proxy" in kwargs:
+            kwargs["proxies"] = kwargs.pop("proxy")
+        return httpx.Client(**kwargs)
+
+
+def _build_plain_async_httpx_client(proxy_url: Optional[str]) -> httpx.AsyncClient:
+    kwargs: Dict[str, Any] = {}
+    if proxy_url:
+        kwargs["proxy"] = proxy_url
+    try:
+        return httpx.AsyncClient(**kwargs)
+    except TypeError:
+        if "proxy" in kwargs:
+            kwargs["proxies"] = kwargs.pop("proxy")
+        return httpx.AsyncClient(**kwargs)
+
 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
+    container = payload.get("data") if isinstance(payload, dict) and isinstance(payload.get("data"), dict) else payload
+    if not isinstance(container, dict):
+        return None, None
+
+    access_token = (
+        container.get("access_token")
+        or container.get("accessToken")
+        or container.get("AccessToken")
+        or payload.get("access_token") if isinstance(payload, dict) else None
+    )
+    refresh_token = (
+        container.get("refresh_token")
+        or container.get("refreshToken")
+        or container.get("RefreshToken")
+        or 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
@@ -69,10 +126,10 @@ class HTTPClient:
         self.access_token: Optional[str] = None
         self.refresh_token: Optional[str] = None
         
-        self.client = httpx.Client(
+        self.client = _build_httpx_client(
             base_url=self.base_url,
             auth=RobotAuth(self._get_or_login, self._refresh),
-            proxy=self.proxy_url
+            proxy_url=self.proxy_url,
         )
 
     def _get_or_login(self) -> str:
@@ -84,7 +141,7 @@ class HTTPClient:
         return token
 
     def _login(self) -> None:
-        with httpx.Client(proxy=self.proxy_url) as c:
+        with _build_plain_httpx_client(self.proxy_url) as c:
             resp = c.post(
                 f"{self.base_url}/api/v1/developer/auth/token",
                 json={"app_id": self.app_id, "app_secret": self.app_secret}
@@ -99,28 +156,10 @@ class HTTPClient:
             raise
 
     def _refresh(self) -> str:
-        # Developer tokens currently don't use refresh flow in the same way, but keeping structure
-        if not self.refresh_token:
-            self._login()
-            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(
-                f"{self.base_url}/api/v1/developer/auth/refresh",
-                json={"refresh_token": self.refresh_token}
-            )
-        if resp.status_code >= 400:
-            self._login()
-        else:
-            data = resp.json()
-            self.access_token, self.refresh_token = _extract_tokens(data)
-
+        self._login()
         token = str(self.access_token).strip() if self.access_token else ""
         if not token:
-            raise RuntimeError("Token refresh failed: empty access token")
+            raise RuntimeError("Empty access token after login")
         return token
 
     def request(self, method: str, path: str, **kwargs: Any) -> Dict[str, Any]:
@@ -132,6 +171,11 @@ class HTTPClient:
                 path = f"/{path}"
             full_path = f"/api/v1/developer{path}"
 
+        headers = dict(kwargs.pop("headers", {}) or {})
+        if "/auth/" not in full_path and "Authorization" not in headers:
+            headers["Authorization"] = f"Bearer {self._get_or_login()}"
+        kwargs["headers"] = headers
+
         print(f"🚀 Requesting: {self.base_url}{full_path}")
         last_err: Optional[Exception] = None
         resp = None
@@ -146,10 +190,10 @@ class HTTPClient:
                     raise
                 last_err = err
                 self.client.close()
-                self.client = httpx.Client(
+                self.client = _build_httpx_client(
                     base_url=self.base_url,
                     auth=RobotAuth(self._get_or_login, self._refresh),
-                    proxy=self.proxy_url,
+                    proxy_url=self.proxy_url,
                 )
 
         if resp is None:
@@ -183,10 +227,10 @@ class AsyncHTTPClient:
         self.access_token: Optional[str] = None
         self.refresh_token: Optional[str] = None
         
-        self.client = httpx.AsyncClient(
+        self.client = _build_async_httpx_client(
             base_url=self.base_url,
             auth=AsyncRobotAuth(self._get_or_login, self._refresh),
-            proxy=self.proxy_url
+            proxy_url=self.proxy_url,
         )
 
     async def _get_or_login(self) -> str:
@@ -198,7 +242,7 @@ class AsyncHTTPClient:
         return token
 
     async def _login(self) -> None:
-        async with httpx.AsyncClient(proxy=self.proxy_url) as c:
+        async with _build_plain_async_httpx_client(self.proxy_url) as c:
             resp = await c.post(
                 f"{self.base_url}/api/v1/developer/auth/token",
                 json={"app_id": self.app_id, "app_secret": self.app_secret}
@@ -213,27 +257,10 @@ class AsyncHTTPClient:
             raise
 
     async def _refresh(self) -> str:
-        if not self.refresh_token:
-            await self._login()
-            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(
-                f"{self.base_url}/api/v1/developer/auth/refresh",
-                json={"refresh_token": self.refresh_token}
-            )
-        if resp.status_code >= 400:
-            await self._login()
-        else:
-            data = resp.json()
-            self.access_token, self.refresh_token = _extract_tokens(data)
-
+        await self._login()
         token = str(self.access_token).strip() if self.access_token else ""
         if not token:
-            raise RuntimeError("Token refresh failed: empty access token")
+            raise RuntimeError("Empty access token after login")
         return token
 
     async def request(self, method: str, path: str, **kwargs: Any) -> Dict[str, Any]:

{robot_wrapper_sdk-0.2.9 → robot_wrapper_sdk-0.2.11}/robot_sdk/infrastructure/robot_api_repository.py

@@ -39,13 +39,26 @@ def _extract_items(resp: Dict[str, Any]) -> List[Dict[str, Any]]:
             return [item for item in nested if isinstance(item, dict)]
     return []
 
+
+def _to_robot_payload(item: Dict[str, Any]) -> Dict[str, Any]:
+    payload = dict(item)
+    payload.setdefault("auth_status", "")
+    payload.setdefault("metadata", {})
+    return payload
+
+
+def _to_robots(items: List[Dict[str, Any]]) -> List[Robot]:
+    return [Robot(**_to_robot_payload(item)) for item in items]
+
 class RobotAPIRepository(RobotRepository):
     def __init__(self, client: HTTPClient):
         self.client = client
 
     def find_by_id(self, robot_id: str) -> Optional[Robot]:
         resp = self.client.request("GET", f"/robots/{robot_id}")
-        return Robot(**resp) if resp else None
+        payload = resp.get("data") if isinstance(resp, dict) else None
+        data = payload if isinstance(payload, dict) else resp
+        return Robot(**_to_robot_payload(data)) if isinstance(data, dict) else None
 
     def update_status(self, robot_id: str, status: str | RobotStatus) -> None:
         normalized_status = normalize_robot_status(status)
@@ -67,7 +80,7 @@ class RobotAPIRepository(RobotRepository):
 
         resp = self.client.request("GET", "/robots", params=params)
         data, total = _extract_list_payload(resp)
-        return [Robot(**r) for r in data], total
+        return _to_robots(data), total
 
     def acquire_need_login(self, limit: int = 20, lock_minutes: int = 30) -> List[Robot]:
         resp = self.client.request(
@@ -76,7 +89,7 @@ class RobotAPIRepository(RobotRepository):
             json={"limit": limit, "lock_minutes": lock_minutes},
         )
         data = _extract_items(resp)
-        return [Robot(**r) for r in data]
+        return _to_robots(data)
 
     def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0) -> List[Robot]:
         resp = self.client.request(
@@ -85,7 +98,7 @@ class RobotAPIRepository(RobotRepository):
             json={"limit": limit, "lock_minutes": lock_minutes, "min_age_days": min_age_days},
         )
         data = _extract_items(resp)
-        return [Robot(**r) for r in data]
+        return _to_robots(data)
 
     def update_auth_status(self, robot_id: str, auth_status: str | RobotAuthStatus) -> None:
         normalized_auth_status = normalize_robot_auth_status(auth_status)
@@ -106,7 +119,7 @@ class RobotAPIRepository(RobotRepository):
     def update_metadata(self, robot_id: str, metadata: Dict[str, Any]) -> None:
         self.client.request(
             "PATCH",
-            f"/robots/{robot_id}",
+            f"/robots/{robot_id}/metadata",
             json={"metadata": metadata},
         )
 
@@ -116,7 +129,9 @@ class AsyncRobotAPIRepository(AsyncRobotRepository):
 
     async def find_by_id(self, robot_id: str) -> Optional[Robot]:
         resp = await self.client.request("GET", f"/robots/{robot_id}")
-        return Robot(**resp) if resp else None
+        payload = resp.get("data") if isinstance(resp, dict) else None
+        data = payload if isinstance(payload, dict) else resp
+        return Robot(**_to_robot_payload(data)) if isinstance(data, dict) else None
 
     async def update_status(self, robot_id: str, status: str | RobotStatus) -> None:
         normalized_status = normalize_robot_status(status)
@@ -138,7 +153,7 @@ class AsyncRobotAPIRepository(AsyncRobotRepository):
 
         resp = await self.client.request("GET", "/robots", params=params)
         data, total = _extract_list_payload(resp)
-        return [Robot(**r) for r in data], total
+        return _to_robots(data), total
 
     async def acquire_need_login(self, limit: int = 20, lock_minutes: int = 30) -> List[Robot]:
         resp = await self.client.request(
@@ -147,7 +162,7 @@ class AsyncRobotAPIRepository(AsyncRobotRepository):
             json={"limit": limit, "lock_minutes": lock_minutes},
         )
         data = _extract_items(resp)
-        return [Robot(**r) for r in data]
+        return _to_robots(data)
 
     async def acquire_unhardened(self, limit: int = 20, lock_minutes: int = 30, min_age_days: int = 0) -> List[Robot]:
         resp = await self.client.request(
@@ -156,7 +171,7 @@ class AsyncRobotAPIRepository(AsyncRobotRepository):
             json={"limit": limit, "lock_minutes": lock_minutes, "min_age_days": min_age_days},
         )
         data = _extract_items(resp)
-        return [Robot(**r) for r in data]
+        return _to_robots(data)
 
     async def update_auth_status(self, robot_id: str, auth_status: str | RobotAuthStatus) -> None:
         normalized_auth_status = normalize_robot_auth_status(auth_status)
@@ -177,6 +192,6 @@ class AsyncRobotAPIRepository(AsyncRobotRepository):
     async def update_metadata(self, robot_id: str, metadata: Dict[str, Any]) -> None:
         await self.client.request(
             "PATCH",
-            f"/robots/{robot_id}",
+            f"/robots/{robot_id}/metadata",
             json={"metadata": metadata},
         )

{robot_wrapper_sdk-0.2.9 → robot_wrapper_sdk-0.2.11}/robot_wrapper_sdk.egg-info/PKG-INFO

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