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

{unitysvc_services-0.2.7/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.2.7
+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.2.7 → unitysvc_services-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unitysvc-services"
-version = "0.2.7"
+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.2.7 → 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,6 +102,174 @@ class ServiceDataPublisher:
 
         return result
 
+    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
+        """
+        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:
+            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
+
+        Raises:
+            ValueError: If task fails or times out
+        """
+        import time
+
+        start_time = time.time()
+
+        while True:
+            elapsed = time.time() - start_time
+            if elapsed > timeout:
+                raise ValueError(f"Task {task_id} timed out after {timeout}s")
+
+            # Check task status using the get() equivalent for async
+            try:
+                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
+
+            state = status.get("state", "PENDING")
+
+            # Check if task is complete
+            if status.get("status") == "completed" or state == "SUCCESS":
+                return status.get("result", {})
+            elif status.get("status") == "failed" or state == "FAILURE":
+                error = status.get("error", "Unknown error")
+                raise ValueError(f"Task {task_id} failed: {error}")
+
+            # Still processing - wait and retry
+            await asyncio.sleep(poll_interval)
+
     async def _post_with_retry(
         self,
         endpoint: str,
@@ -107,7 +280,13 @@ class ServiceDataPublisher:
         max_retries: int = 3,
     ) -> dict[str, Any]:
         """
-        Generic retry wrapper for posting data to backend API.
+        Generic retry wrapper for posting data to backend API with task polling.
+
+        The backend now returns HTTP 202 with a task_id. This method:
+        1. Submits the publish request
+        2. Gets the task_id from the response
+        3. Polls /tasks/{task_id} until completion
+        4. Returns the final result
 
         Args:
             endpoint: API endpoint path (e.g., "/publish/listing")
@@ -126,50 +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)
 
-                # Provide detailed error information if request fails
-                if not response.is_success:
-                    # 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}"
+                # Handle task-based response (HTTP 202)
+                if status_code == 202:
+                    # Backend returns task_id - poll for completion
+                    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 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}")
+
+                # Check for errors
+                if status_code >= 400:
+                    # Don't retry on 4xx errors (client errors) - they won't succeed on retry
+                    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}"
                         )
 
-                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
@@ -478,7 +664,7 @@ class ServiceDataPublisher:
                 console.print(f"  [red]✗[/red] Failed to publish offering: [cyan]{offering_name}[/cyan] - {str(e)}")
                 return (offering_file, e)
 
-    def publish_all_offerings(self, data_dir: Path) -> dict[str, Any]:
+    async def publish_all_offerings(self, data_dir: Path) -> dict[str, Any]:
         """
         Publish all service offerings found in a directory tree concurrently.
 
@@ -510,14 +696,10 @@ class ServiceDataPublisher:
         console = Console()
 
         # Run all offering publications concurrently with rate limiting
-        async def _publish_all() -> list[tuple[Path, dict[str, Any] | Exception]]:
-            # Create semaphore to limit concurrent requests
-            semaphore = asyncio.Semaphore(self.max_concurrent_requests)
-            tasks = [self._publish_offering_task(offering_file, console, semaphore) for offering_file in offering_files]
-            return await asyncio.gather(*tasks)
-
-        # Execute async tasks
-        task_results = asyncio.run(_publish_all())
+        # Create semaphore to limit concurrent requests
+        semaphore = asyncio.Semaphore(self.max_concurrent_requests)
+        tasks = [self._publish_offering_task(offering_file, console, semaphore) for offering_file in offering_files]
+        task_results = await asyncio.gather(*tasks)
 
         # Process results
         for offering_file, result in task_results:
@@ -565,7 +747,7 @@ class ServiceDataPublisher:
                 console.print(f"  [red]✗[/red] Failed to publish listing: [cyan]{listing_file}[/cyan] - {str(e)}")
                 return (listing_file, e)
 
-    def publish_all_listings(self, data_dir: Path) -> dict[str, Any]:
+    async def publish_all_listings(self, data_dir: Path) -> dict[str, Any]:
         """
         Publish all service listings found in a directory tree concurrently.
 
@@ -597,14 +779,10 @@ class ServiceDataPublisher:
         console = Console()
 
         # Run all listing publications concurrently with rate limiting
-        async def _publish_all() -> list[tuple[Path, dict[str, Any] | Exception]]:
-            # Create semaphore to limit concurrent requests
-            semaphore = asyncio.Semaphore(self.max_concurrent_requests)
-            tasks = [self._publish_listing_task(listing_file, console, semaphore) for listing_file in listing_files]
-            return await asyncio.gather(*tasks)
-
-        # Execute async tasks
-        task_results = asyncio.run(_publish_all())
+        # Create semaphore to limit concurrent requests
+        semaphore = asyncio.Semaphore(self.max_concurrent_requests)
+        tasks = [self._publish_listing_task(listing_file, console, semaphore) for listing_file in listing_files]
+        task_results = await asyncio.gather(*tasks)
 
         # Process results
         for listing_file, result in task_results:
@@ -647,7 +825,7 @@ class ServiceDataPublisher:
                 console.print(f"  [red]✗[/red] Failed to publish provider: [cyan]{provider_name}[/cyan] - {str(e)}")
                 return (provider_file, e)
 
-    def publish_all_providers(self, data_dir: Path) -> dict[str, Any]:
+    async def publish_all_providers(self, data_dir: Path) -> dict[str, Any]:
         """
         Publish all providers found in a directory tree concurrently.
 
@@ -667,14 +845,10 @@ class ServiceDataPublisher:
         console = Console()
 
         # Run all provider publications concurrently with rate limiting
-        async def _publish_all() -> list[tuple[Path, dict[str, Any] | Exception]]:
-            # Create semaphore to limit concurrent requests
-            semaphore = asyncio.Semaphore(self.max_concurrent_requests)
-            tasks = [self._publish_provider_task(provider_file, console, semaphore) for provider_file in provider_files]
-            return await asyncio.gather(*tasks)
-
-        # Execute async tasks
-        task_results = asyncio.run(_publish_all())
+        # Create semaphore to limit concurrent requests
+        semaphore = asyncio.Semaphore(self.max_concurrent_requests)
+        tasks = [self._publish_provider_task(provider_file, console, semaphore) for provider_file in provider_files]
+        task_results = await asyncio.gather(*tasks)
 
         # Process results
         for provider_file, result in task_results:
@@ -717,7 +891,7 @@ class ServiceDataPublisher:
                 console.print(f"  [red]✗[/red] Failed to publish seller: [cyan]{seller_name}[/cyan] - {str(e)}")
                 return (seller_file, e)
 
-    def publish_all_sellers(self, data_dir: Path) -> dict[str, Any]:
+    async def publish_all_sellers(self, data_dir: Path) -> dict[str, Any]:
         """
         Publish all sellers found in a directory tree concurrently.
 
@@ -737,14 +911,10 @@ class ServiceDataPublisher:
         console = Console()
 
         # Run all seller publications concurrently with rate limiting
-        async def _publish_all() -> list[tuple[Path, dict[str, Any] | Exception]]:
-            # Create semaphore to limit concurrent requests
-            semaphore = asyncio.Semaphore(self.max_concurrent_requests)
-            tasks = [self._publish_seller_task(seller_file, console, semaphore) for seller_file in seller_files]
-            return await asyncio.gather(*tasks)
-
-        # Execute async tasks
-        task_results = asyncio.run(_publish_all())
+        # Create semaphore to limit concurrent requests
+        semaphore = asyncio.Semaphore(self.max_concurrent_requests)
+        tasks = [self._publish_seller_task(seller_file, console, semaphore) for seller_file in seller_files]
+        task_results = await asyncio.gather(*tasks)
 
         # Process results
         for seller_file, result in task_results:
@@ -756,7 +926,7 @@ class ServiceDataPublisher:
 
         return results
 
-    def publish_all_models(self, data_dir: Path) -> dict[str, Any]:
+    async def publish_all_models(self, data_dir: Path) -> dict[str, Any]:
         """
         Publish all data types in the correct order.
 
@@ -788,7 +958,7 @@ class ServiceDataPublisher:
 
         for data_type, publish_method in publish_order:
             try:
-                results = publish_method(data_dir)
+                results = await publish_method(data_dir)
                 all_results[data_type] = results
                 all_results["total_success"] += results["success"]
                 all_results["total_failed"] += results["failed"]
@@ -805,9 +975,25 @@ class ServiceDataPublisher:
 
         return all_results
 
+    async def aclose(self):
+        """Close HTTP client asynchronously."""
+        await self.async_client.aclose()
+
     def close(self):
-        """Close HTTP client."""
-        asyncio.run(self.async_client.aclose())
+        """Close HTTP client synchronously (best effort)."""
+        try:
+            # Try to close if there's an event loop running
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # Can't close synchronously if loop is running
+                # The client will be garbage collected
+                return
+            else:
+                # Loop exists but not running, we can use it
+                loop.run_until_complete(self.async_client.aclose())
+        except RuntimeError:
+            # No event loop or loop is closed - just let it be garbage collected
+            pass
 
     def __enter__(self):
         """Context manager entry."""
@@ -870,8 +1056,8 @@ def publish_callback(
 
     try:
         with ServiceDataPublisher() as publisher:
-            # Call the publish_all_models method
-            all_results = publisher.publish_all_models(data_path)
+            # Call the publish_all_models method (now async)
+            all_results = asyncio.run(publisher.publish_all_models(data_path))
 
             # Display results for each data type
             data_type_display_names = {
@@ -965,7 +1151,7 @@ def publish_providers(
             else:
                 console.print(f"[blue]Scanning for providers in:[/blue] {data_path}")
                 console.print(f"[blue]Backend URL:[/blue] {os.getenv('UNITYSVC_BASE_URL', 'N/A')}\n")
-                results = publisher.publish_all_providers(data_path)
+                results = asyncio.run(publisher.publish_all_providers(data_path))
 
                 # Display summary
                 console.print("\n[bold]Publishing Summary:[/bold]")
@@ -1024,7 +1210,7 @@ def publish_sellers(
             else:
                 console.print(f"[blue]Scanning for sellers in:[/blue] {data_path}")
                 console.print(f"[blue]Backend URL:[/blue] {os.getenv('UNITYSVC_BASE_URL', 'N/A')}\n")
-                results = publisher.publish_all_sellers(data_path)
+                results = asyncio.run(publisher.publish_all_sellers(data_path))
 
                 console.print("\n[bold]Publishing Summary:[/bold]")
                 console.print(f"  Total found: {results['total']}")
@@ -1080,8 +1266,8 @@ def publish_offerings(
             # Handle directory
             else:
                 console.print(f"[blue]Scanning for service offerings in:[/blue] {data_path}")
-                console.print(f"[blue]Backend URL:[/blue] {os.getenv('UNITYSVC_BASE_URL', 'N/A')}\n")
-                results = publisher.publish_all_offerings(data_path)
+                console.print(f"[blue]Backend URL:[/bold blue] {os.getenv('UNITYSVC_BASE_URL', 'N/A')}\n")
+                results = asyncio.run(publisher.publish_all_offerings(data_path))
 
                 console.print("\n[bold]Publishing Summary:[/bold]")
                 console.print(f"  Total found: {results['total']}")
@@ -1139,7 +1325,7 @@ def publish_listings(
             else:
                 console.print(f"[blue]Scanning for service listings in:[/blue] {data_path}")
                 console.print(f"[blue]Backend URL:[/blue] {os.getenv('UNITYSVC_BASE_URL', 'N/A')}\n")
-                results = publisher.publish_all_listings(data_path)
+                results = asyncio.run(publisher.publish_all_listings(data_path))
 
                 console.print("\n[bold]Publishing Summary:[/bold]")
                 console.print(f"  Total found: {results['total']}")

{unitysvc_services-0.2.7 → 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.2.7 → 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.2.7
+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>