unitysvc-services 0.3.0__tar.gz → 0.3.1__tar.gz

{unitysvc_services-0.3.0/src/unitysvc_services.egg-info → unitysvc_services-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-services
-Version: 0.3.0
+Version: 0.3.1
 Summary: SDK for digital service providers on UnitySVC
 Author-email: Bo Peng <bo.peng@unitysvc.com>
 Maintainer-email: Bo Peng <bo.peng@unitysvc.com>

{unitysvc_services-0.3.0 → unitysvc_services-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unitysvc-services"
-version = "0.3.0"
+version = "0.3.1"
 description = "SDK for digital service providers on UnitySVC"
 readme = "README.md"
 authors = [{ name = "Bo Peng", email = "bo.peng@unitysvc.com" }]

{unitysvc_services-0.3.0 → unitysvc_services-0.3.1}/src/unitysvc_services/publisher.py

@@ -18,7 +18,11 @@ from .validator import DataValidator
 
 
 class ServiceDataPublisher:
-    """Publishes service data to UnitySVC backend endpoints."""
+    """Publishes service data to UnitySVC backend endpoints.
+
+    Uses httpx by default, with automatic fallback to curl for systems
+    with network restrictions (e.g., macOS with conda Python).
+    """
 
     def __init__(self) -> None:
         self.base_url = os.environ.get("UNITYSVC_BASE_URL")
@@ -30,6 +34,7 @@ class ServiceDataPublisher:
             raise ValueError("UNITYSVC_API_KEY environment variable not set")
 
         self.base_url = self.base_url.rstrip("/")
+        self.use_curl_fallback = False
         self.async_client = httpx.AsyncClient(
             headers={
                 "X-API-Key": self.api_key,
@@ -97,25 +102,128 @@ class ServiceDataPublisher:
 
         return result
 
-    async def _poll_task_status(
-        self,
-        task_id: str,
-        entity_type: str,
-        entity_name: str,
-        context_info: str = "",
-        poll_interval: float = 2.0,
-        timeout: float = 300.0,
-    ) -> dict[str, Any]:
+    async def _make_request_curl_async(
+        self, endpoint: str, method: str = "GET", data: dict[str, Any] | None = None
+    ) -> tuple[dict[str, Any], int]:
+        """Make HTTP request using curl (async version).
+
+        Args:
+            endpoint: API endpoint path
+            method: HTTP method (GET or POST)
+            data: JSON data for POST requests
+
+        Returns:
+            Tuple of (JSON response, HTTP status code)
+
+        Raises:
+            RuntimeError: If curl command fails
         """
-        Poll task status until completion or timeout.
+        url = f"{self.base_url}{endpoint}"
+
+        cmd = [
+            "curl",
+            "-s",  # Silent mode
+            "-w",
+            "\n%{http_code}",  # Write HTTP status code on new line
+            "-X",
+            method,
+            "-H",
+            f"X-API-Key: {self.api_key}",
+            "-H",
+            "Content-Type: application/json",
+        ]
+
+        if data:
+            cmd.extend(["-d", json.dumps(data)])
+
+        cmd.append(url)
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=30.0)
+
+            if proc.returncode != 0:
+                error_msg = stderr.decode().strip() if stderr else "Unknown error"
+                raise RuntimeError(f"curl command failed: {error_msg}")
+
+            output = stdout.decode().strip()
+            lines = output.split("\n")
+            status_code = int(lines[-1])
+            body = "\n".join(lines[:-1])
+
+            response_data = json.loads(body) if body else {}
+            return (response_data, status_code)
+
+        except TimeoutError:
+            raise RuntimeError("Request timed out after 30 seconds")
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Invalid JSON response: {e}")
+
+    async def post(self, endpoint: str, data: dict[str, Any], check_status: bool = True) -> tuple[dict[str, Any], int]:
+        """Make a POST request to the backend API with automatic curl fallback.
+
+        Public utility method for making POST requests. Tries httpx first for performance,
+        automatically falls back to curl if network restrictions are detected (e.g., macOS
+        with conda Python).
+
+        Can be used by other packages that need the same fallback behavior.
 
         Args:
-            task_id: Celery task ID
-            entity_type: Type of entity being published (for error messages)
-            entity_name: Name of the entity being published (for error messages)
-            context_info: Additional context for error messages
-            poll_interval: Seconds between status checks
-            timeout: Maximum seconds to wait
+            endpoint: API endpoint path (e.g., "/publish/seller")
+            data: JSON data to post
+            check_status: Whether to raise on non-2xx status codes (default: True)
+
+        Returns:
+            Tuple of (JSON response, HTTP status code)
+
+        Raises:
+            RuntimeError: If both httpx and curl fail
+        """
+
+        # Helper class to simulate httpx response for curl
+        class CurlResponse:
+            def __init__(self, json_data: dict[str, Any], status: int):
+                self._json_data = json_data
+                self.status_code = status
+                self.is_success = 200 <= status < 300
+                self.text = json.dumps(json_data)
+
+            def json(self) -> dict[str, Any]:
+                return self._json_data
+
+            def raise_for_status(self) -> None:
+                if not self.is_success:
+                    raise RuntimeError(f"HTTP {self.status_code}: {self.text}")
+
+        # If we already know curl is needed, use it directly
+        if self.use_curl_fallback:
+            response_data, status_code = await self._make_request_curl_async(endpoint, method="POST", data=data)
+            response = CurlResponse(response_data, status_code)
+        else:
+            try:
+                response = await self.async_client.post(f"{self.base_url}{endpoint}", json=data)
+            except (httpx.ConnectError, OSError):
+                # Connection failed - switch to curl fallback and retry
+                self.use_curl_fallback = True
+                response_data, status_code = await self._make_request_curl_async(endpoint, method="POST", data=data)
+                response = CurlResponse(response_data, status_code)
+
+        if check_status:
+            response.raise_for_status()
+
+        return (response.json(), response.status_code)
+
+    async def check_task(self, task_id: str, poll_interval: float = 2.0, timeout: float = 300.0) -> dict[str, Any]:
+        """Check and wait for task completion.
+
+        Utility function to poll a Celery task until it completes or times out.
+
+        Args:
+            task_id: Celery task ID to poll
+            poll_interval: Seconds between status checks (default: 2.0)
+            timeout: Maximum seconds to wait (default: 300.0)
 
         Returns:
             Task result dictionary
@@ -130,15 +238,22 @@ class ServiceDataPublisher:
         while True:
             elapsed = time.time() - start_time
             if elapsed > timeout:
-                context_msg = f" ({context_info})" if context_info else ""
-                raise ValueError(f"Task timed out after {timeout}s for {entity_type} '{entity_name}'{context_msg}")
+                raise ValueError(f"Task {task_id} timed out after {timeout}s")
 
-            # Check task status
+            # Check task status using the get() equivalent for async
             try:
-                response = await self.async_client.get(f"{self.base_url}/tasks/{task_id}")
-                response.raise_for_status()
-                status = response.json()
-            except (httpx.HTTPError, httpx.NetworkError, httpx.TimeoutException):
+                if self.use_curl_fallback:
+                    status, _ = await self._make_request_curl_async(f"/tasks/{task_id}", method="GET")
+                else:
+                    try:
+                        response = await self.async_client.get(f"{self.base_url}/tasks/{task_id}")
+                        response.raise_for_status()
+                        status = response.json()
+                    except (httpx.ConnectError, OSError):
+                        # Connection failed - switch to curl fallback
+                        self.use_curl_fallback = True
+                        status, _ = await self._make_request_curl_async(f"/tasks/{task_id}", method="GET")
+            except (httpx.HTTPError, httpx.NetworkError, httpx.TimeoutException, RuntimeError):
                 # Network error while checking status - retry
                 await asyncio.sleep(poll_interval)
                 continue
@@ -147,13 +262,10 @@ class ServiceDataPublisher:
 
             # Check if task is complete
             if status.get("status") == "completed" or state == "SUCCESS":
-                # Task succeeded
                 return status.get("result", {})
             elif status.get("status") == "failed" or state == "FAILURE":
-                # Task failed
                 error = status.get("error", "Unknown error")
-                context_msg = f" ({context_info})" if context_info else ""
-                raise ValueError(f"Task failed for {entity_type} '{entity_name}'{context_msg}: {error}")
+                raise ValueError(f"Task {task_id} failed: {error}")
 
             # Still processing - wait and retry
             await asyncio.sleep(poll_interval)
@@ -193,70 +305,57 @@ class ServiceDataPublisher:
         last_exception = None
         for attempt in range(max_retries):
             try:
-                response = await self.async_client.post(
-                    f"{self.base_url}{endpoint}",
-                    json=data,
-                )
+                # Use the public post() method with automatic curl fallback
+                response_json, status_code = await self.post(endpoint, data, check_status=False)
 
                 # Handle task-based response (HTTP 202)
-                if response.status_code == 202:
+                if status_code == 202:
                     # Backend returns task_id - poll for completion
-                    response_data = response.json()
-                    task_id = response_data.get("task_id")
+                    task_id = response_json.get("task_id")
 
                     if not task_id:
                         context_msg = f" ({context_info})" if context_info else ""
                         raise ValueError(f"No task_id in response for {entity_type} '{entity_name}'{context_msg}")
 
-                    # Poll task status until completion
-                    result = await self._poll_task_status(
-                        task_id=task_id,
-                        entity_type=entity_type,
-                        entity_name=entity_name,
-                        context_info=context_info,
-                    )
-                    return result
+                    # Poll task status until completion using check_task utility
+                    try:
+                        result = await self.check_task(task_id)
+                        return result
+                    except ValueError as e:
+                        # Add context to task errors
+                        context_msg = f" ({context_info})" if context_info else ""
+                        raise ValueError(f"Task failed for {entity_type} '{entity_name}'{context_msg}: {e}")
 
-                # Provide detailed error information if request fails
-                if not response.is_success:
+                # Check for errors
+                if status_code >= 400:
                     # Don't retry on 4xx errors (client errors) - they won't succeed on retry
-                    if 400 <= response.status_code < 500:
-                        error_detail = "Unknown error"
-                        try:
-                            error_json = response.json()
-                            error_detail = error_json.get("detail", str(error_json))
-                        except Exception:
-                            error_detail = response.text or f"HTTP {response.status_code}"
-
+                    if 400 <= status_code < 500:
+                        error_detail = response_json.get("detail", str(response_json))
                         context_msg = f" ({context_info})" if context_info else ""
                         raise ValueError(
                             f"Failed to publish {entity_type} '{entity_name}'{context_msg}: {error_detail}"
                         )
 
-                    # 5xx errors or network errors - retry with exponential backoff
+                    # 5xx errors - retry with exponential backoff
                     if attempt < max_retries - 1:
                         wait_time = 2**attempt  # Exponential backoff: 1s, 2s, 4s
                         await asyncio.sleep(wait_time)
                         continue
                     else:
                         # Last attempt failed
-                        error_detail = "Unknown error"
-                        try:
-                            error_json = response.json()
-                            error_detail = error_json.get("detail", str(error_json))
-                        except Exception:
-                            error_detail = response.text or f"HTTP {response.status_code}"
-
+                        error_detail = response_json.get("detail", str(response_json))
                         context_msg = f" ({context_info})" if context_info else ""
                         raise ValueError(
                             f"Failed to publish {entity_type} after {max_retries} attempts: "
                             f"'{entity_name}'{context_msg}: {error_detail}"
                         )
 
-                # For non-202 success responses, return the body
-                return response.json()
+                # Success response (2xx)
+                return response_json
 
-            except (httpx.NetworkError, httpx.TimeoutException) as e:
+            except (httpx.NetworkError, httpx.TimeoutException, RuntimeError) as e:
+                # Network/connection errors - the post() method should have tried curl fallback
+                # If we're here, both httpx and curl failed
                 last_exception = e
                 if attempt < max_retries - 1:
                     wait_time = 2**attempt  # Exponential backoff: 1s, 2s, 4s

{unitysvc_services-0.3.0 → unitysvc_services-0.3.1}/src/unitysvc_services/query.py

@@ -2,7 +2,9 @@
 
 import json
 import os
+import subprocess
 from typing import Any
+from urllib.parse import urlencode
 
 import httpx
 import typer
@@ -14,7 +16,11 @@ console = Console()
 
 
 class ServiceDataQuery:
-    """Query service data from UnitySVC backend endpoints."""
+    """Query service data from UnitySVC backend endpoints.
+
+    Uses httpx by default, with automatic fallback to curl for systems
+    with network restrictions (e.g., macOS with conda Python).
+    """
 
     def __init__(self) -> None:
         """Initialize query client from environment variables.
@@ -31,6 +37,7 @@ class ServiceDataQuery:
             raise ValueError("UNITYSVC_API_KEY environment variable not set")
 
         self.base_url = self.base_url.rstrip("/")
+        self.use_curl_fallback = False
         self.client = httpx.Client(
             headers={
                 "X-API-Key": self.api_key,
@@ -39,6 +46,80 @@ class ServiceDataQuery:
             timeout=30.0,
         )
 
+    def _make_request_curl(self, endpoint: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Make HTTP GET request using curl fallback.
+
+        Args:
+            endpoint: API endpoint path (e.g., "/publish/sellers")
+            params: Query parameters
+
+        Returns:
+            JSON response as dictionary
+
+        Raises:
+            RuntimeError: If curl command fails or returns non-200 status
+        """
+        url = f"{self.base_url}{endpoint}"
+        if params:
+            url = f"{url}?{urlencode(params)}"
+
+        cmd = [
+            "curl",
+            "-s",  # Silent mode
+            "-f",  # Fail on HTTP errors
+            "-H",
+            f"X-API-Key: {self.api_key}",
+            "-H",
+            "Accept: application/json",
+            url,
+        ]
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=30)
+            return json.loads(result.stdout)
+        except subprocess.CalledProcessError as e:
+            error_msg = e.stderr.strip() if e.stderr else "Unknown error"
+            raise RuntimeError(f"HTTP request failed: {error_msg}")
+        except subprocess.TimeoutExpired:
+            raise RuntimeError("Request timed out after 30 seconds")
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Invalid JSON response: {e}")
+
+    def get(self, endpoint: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Make a GET request to the backend API with automatic curl fallback.
+
+        Public utility method for making GET requests. Tries httpx first for performance,
+        automatically falls back to curl if network restrictions are detected (e.g., macOS
+        with conda Python).
+
+        Can be used by subclasses and other packages (e.g., unitysvc_admin) that need
+        the same fallback behavior.
+
+        Args:
+            endpoint: API endpoint path (e.g., "/publish/sellers", "/admin/documents")
+            params: Query parameters
+
+        Returns:
+            JSON response as dictionary
+
+        Raises:
+            RuntimeError: If both httpx and curl fail
+        """
+        # If we already know curl is needed, use it directly
+        if self.use_curl_fallback:
+            return self._make_request_curl(endpoint, params)
+
+        # Try httpx first
+        try:
+            response = self.client.get(f"{self.base_url}{endpoint}", params=params)
+            response.raise_for_status()
+            return response.json()
+        except (httpx.ConnectError, OSError) as e:
+            # Connection failed - likely network restrictions
+            # Fall back to curl and remember this for future requests
+            self.use_curl_fallback = True
+            return self._make_request_curl(endpoint, params)
+
     def list_service_offerings(self, skip: int = 0, limit: int = 100) -> list[dict[str, Any]]:
         """List all service offerings from the backend.
 
@@ -46,9 +127,7 @@ class ServiceDataQuery:
             skip: Number of records to skip (for pagination)
             limit: Maximum number of records to return
         """
-        response = self.client.get(f"{self.base_url}/publish/offerings", params={"skip": skip, "limit": limit})
-        response.raise_for_status()
-        result = response.json()
+        result = self.get("/publish/offerings", {"skip": skip, "limit": limit})
         return result.get("data", result) if isinstance(result, dict) else result
 
     def list_service_listings(self, skip: int = 0, limit: int = 100) -> list[dict[str, Any]]:
@@ -58,9 +137,7 @@ class ServiceDataQuery:
             skip: Number of records to skip (for pagination)
             limit: Maximum number of records to return
         """
-        response = self.client.get(f"{self.base_url}/publish/listings", params={"skip": skip, "limit": limit})
-        response.raise_for_status()
-        result = response.json()
+        result = self.get("/publish/listings", {"skip": skip, "limit": limit})
         return result.get("data", result) if isinstance(result, dict) else result
 
     def list_providers(self, skip: int = 0, limit: int = 100) -> list[dict[str, Any]]:
@@ -70,9 +147,7 @@ class ServiceDataQuery:
             skip: Number of records to skip (for pagination)
             limit: Maximum number of records to return
         """
-        response = self.client.get(f"{self.base_url}/publish/providers", params={"skip": skip, "limit": limit})
-        response.raise_for_status()
-        result = response.json()
+        result = self.get("/publish/providers", {"skip": skip, "limit": limit})
         return result.get("data", result) if isinstance(result, dict) else result
 
     def list_sellers(self, skip: int = 0, limit: int = 100) -> list[dict[str, Any]]:
@@ -82,14 +157,12 @@ class ServiceDataQuery:
             skip: Number of records to skip (for pagination)
             limit: Maximum number of records to return
         """
-        response = self.client.get(f"{self.base_url}/publish/sellers", params={"skip": skip, "limit": limit})
-        response.raise_for_status()
-        result = response.json()
+        result = self.get("/publish/sellers", {"skip": skip, "limit": limit})
         return result.get("data", result) if isinstance(result, dict) else result
 
     def close(self):
-        """Close the HTTP client."""
-        self.client.close()
+        """Close the HTTP client (no-op for curl-based implementation)."""
+        pass
 
     def __enter__(self):
         """Context manager entry."""

{unitysvc_services-0.3.0 → unitysvc_services-0.3.1/src/unitysvc_services.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-services
-Version: 0.3.0
+Version: 0.3.1
 Summary: SDK for digital service providers on UnitySVC
 Author-email: Bo Peng <bo.peng@unitysvc.com>
 Maintainer-email: Bo Peng <bo.peng@unitysvc.com>