unitysvc-services 0.2.6__py3-none-any.whl → 0.3.0__py3-none-any.whl

unitysvc_services/publisher.py

@@ -1,5 +1,6 @@
 """Data publisher module for posting service data to UnitySVC backend."""
 
+import asyncio
 import base64
 import json
 import os
@@ -29,13 +30,15 @@ class ServiceDataPublisher:
             raise ValueError("UNITYSVC_API_KEY environment variable not set")
 
         self.base_url = self.base_url.rstrip("/")
-        self.client = httpx.Client(
+        self.async_client = httpx.AsyncClient(
             headers={
                 "X-API-Key": self.api_key,
                 "Content-Type": "application/json",
             },
             timeout=30.0,
         )
+        # Semaphore to limit concurrent requests and prevent connection pool exhaustion
+        self.max_concurrent_requests = 15
 
     def load_data_file(self, file_path: Path) -> dict[str, Any]:
         """Load data from JSON or TOML file."""
@@ -94,106 +97,221 @@ class ServiceDataPublisher:
 
         return result
 
-    def post_service_offering(self, data_file: Path) -> dict[str, Any]:
-        """Post service offering data to the backend.
-
-        Extracts provider_name from the directory structure.
-        Expected path: .../{provider_name}/services/{service_name}/...
+    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]:
         """
+        Poll task status until completion or timeout.
 
-        # Load the data file
-        data = self.load_data_file(data_file)
+        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
 
-        # Resolve file references and include content
-        base_path = data_file.parent
-        data = convert_convenience_fields_to_documents(
-            data, base_path, logo_field="logo", terms_field="terms_of_service"
-        )
+        Returns:
+            Task result dictionary
 
-        # Resolve file references and include content
-        data_with_content = self.resolve_file_references(data, base_path)
+        Raises:
+            ValueError: If task fails or times out
+        """
+        import time
 
-        # Extract provider_name from directory structure
-        # Find the 'services' directory and use its parent as provider_name
-        parts = data_file.parts
-        try:
-            services_idx = parts.index("services")
-            provider_name = parts[services_idx - 1]
-            data_with_content["provider_name"] = provider_name
+        start_time = time.time()
 
-            # Find provider directory to check status
-            provider_dir = Path(*parts[:services_idx])
-        except (ValueError, IndexError):
-            raise ValueError(
-                f"Cannot extract provider_name from path: {data_file}. "
-                f"Expected path to contain .../{{provider_name}}/services/..."
-            )
+        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}")
 
-        # Check provider status - skip if incomplete
-        provider_files = find_files_by_schema(provider_dir, "provider_v1")
-        if provider_files:
-            # Should only be one provider file in the directory
-            _provider_file, _format, provider_data = provider_files[0]
-            provider_status = provider_data.get("status", ProviderStatusEnum.active)
-            if provider_status == ProviderStatusEnum.incomplete:
-                return {
-                    "skipped": True,
-                    "reason": f"Provider status is '{provider_status}' - not publishing offering to backend",
-                    "name": data.get("name", "unknown"),
-                }
+            # Check task status
+            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):
+                # 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":
+                # 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}")
+
+            # Still processing - wait and retry
+            await asyncio.sleep(poll_interval)
+
+    async def _post_with_retry(
+        self,
+        endpoint: str,
+        data: dict[str, Any],
+        entity_type: str,
+        entity_name: str,
+        context_info: str = "",
+        max_retries: int = 3,
+    ) -> dict[str, Any]:
+        """
+        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")
+            data: JSON data to post
+            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 (e.g., provider, service info)
+            max_retries: Maximum number of retry attempts
+
+        Returns:
+            Response JSON from successful API call
+
+        Raises:
+            ValueError: On client errors (4xx) or after exhausting retries
+        """
+        last_exception = None
+        for attempt in range(max_retries):
+            try:
+                response = await self.async_client.post(
+                    f"{self.base_url}{endpoint}",
+                    json=data,
+                )
 
-        # Post to the endpoint
-        response = self.client.post(
-            f"{self.base_url}/publish/offering",
-            json=data_with_content,
-        )
-        response.raise_for_status()
-        return response.json()
+                # Handle task-based response (HTTP 202)
+                if response.status_code == 202:
+                    # Backend returns task_id - poll for completion
+                    response_data = response.json()
+                    task_id = response_data.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
+
+                # 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}"
+
+                        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
+                    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}"
+
+                        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()
+
+            except (httpx.NetworkError, httpx.TimeoutException) as e:
+                last_exception = e
+                if attempt < max_retries - 1:
+                    wait_time = 2**attempt  # Exponential backoff: 1s, 2s, 4s
+                    await asyncio.sleep(wait_time)
+                    continue
+                else:
+                    raise ValueError(
+                        f"Network error after {max_retries} attempts for {entity_type} '{entity_name}': {str(e)}"
+                    )
 
-    def post_service_listing(self, data_file: Path) -> dict[str, Any]:
-        """Post service listing data to the backend.
+        # Should never reach here, but just in case
+        if last_exception:
+            raise last_exception
+        raise ValueError("Unexpected error in retry logic")
 
-        Extracts provider_name from directory structure and service info from service.json.
-        Expected path: .../{provider_name}/services/{service_name}/svcreseller.json
-        """
+    async def post_service_listing_async(self, listing_file: Path, max_retries: int = 3) -> dict[str, Any]:
+        """Async version of post_service_listing for concurrent publishing with retry logic."""
         # Load the listing data file
-        data = self.load_data_file(data_file)
+        data = self.load_data_file(listing_file)
 
         # If name is not provided, use filename (without extension)
         if "name" not in data or not data.get("name"):
-            data["name"] = data_file.stem
+            data["name"] = listing_file.stem
 
         # Resolve file references and include content
-        base_path = data_file.parent
+        base_path = listing_file.parent
         data_with_content = self.resolve_file_references(data, base_path)
 
         # Extract provider_name from directory structure
-        parts = data_file.parts
+        parts = listing_file.parts
         try:
             services_idx = parts.index("services")
             provider_name = parts[services_idx - 1]
             data_with_content["provider_name"] = provider_name
         except (ValueError, IndexError):
             raise ValueError(
-                f"Cannot extract provider_name from path: {data_file}. "
+                f"Cannot extract provider_name from path: {listing_file}. "
                 f"Expected path to contain .../{{provider_name}}/services/..."
             )
 
         # If service_name is not in listing data, find it from service files in the same directory
         if "service_name" not in data_with_content or not data_with_content["service_name"]:
             # Find all service files in the same directory
-            service_files = find_files_by_schema(data_file.parent, "service_v1")
+            service_files = find_files_by_schema(listing_file.parent, "service_v1")
 
             if len(service_files) == 0:
                 raise ValueError(
-                    f"Cannot find any service_v1 files in {data_file.parent}. "
+                    f"Cannot find any service_v1 files in {listing_file.parent}. "
                     f"Listing files must be in the same directory as a service definition."
                 )
             elif len(service_files) > 1:
                 service_names = [data.get("name", "unknown") for _, _, data in service_files]
                 raise ValueError(
-                    f"Multiple services found in {data_file.parent}: {', '.join(service_names)}. "
-                    f"Please add 'service_name' field to {data_file.name} to specify which "
+                    f"Multiple services found in {listing_file.parent}: {', '.join(service_names)}. "
+                    f"Please add 'service_name' field to {listing_file.name} to specify which "
                     f"service this listing belongs to."
                 )
             else:
@@ -204,11 +322,13 @@ class ServiceDataPublisher:
         else:
             # service_name is provided in listing data, find the matching service to get version
             service_name = data_with_content["service_name"]
-            service_files = find_files_by_schema(data_file.parent, "service_v1", field_filter=(("name", service_name),))
+            service_files = find_files_by_schema(
+                listing_file.parent, "service_v1", field_filter=(("name", service_name),)
+            )
 
             if not service_files:
                 raise ValueError(
-                    f"Service '{service_name}' specified in {data_file.name} not found in {data_file.parent}."
+                    f"Service '{service_name}' specified in {listing_file.name} not found in {listing_file.parent}."
                 )
 
             # Get version from the found service
@@ -217,13 +337,13 @@ class ServiceDataPublisher:
 
         # Find seller_name from seller definition in the data directory
         # Navigate up to find the data directory and look for seller file
-        data_dir = data_file.parent
+        data_dir = listing_file.parent
         while data_dir.name != "data" and data_dir.parent != data_dir:
             data_dir = data_dir.parent
 
         if data_dir.name != "data":
             raise ValueError(
-                f"Cannot find 'data' directory in path: {data_file}. "
+                f"Cannot find 'data' directory in path: {listing_file}. "
                 f"Expected path structure includes a 'data' directory."
             )
 
@@ -257,17 +377,77 @@ class ServiceDataPublisher:
         if "listing_status" in data_with_content:
             data_with_content["status"] = data_with_content.pop("listing_status")
 
-        # Post to the endpoint
-        response = self.client.post(
-            f"{self.base_url}/publish/listing",
-            json=data_with_content,
+        # Post to the endpoint using retry helper
+        context_info = (
+            f"service: {data_with_content.get('service_name')}, "
+            f"provider: {data_with_content.get('provider_name')}, "
+            f"seller: {data_with_content.get('seller_name')}"
+        )
+        return await self._post_with_retry(
+            endpoint="/publish/listing",
+            data=data_with_content,
+            entity_type="listing",
+            entity_name=data.get("name", "unknown"),
+            context_info=context_info,
+            max_retries=max_retries,
+        )
+
+    async def post_service_offering_async(self, data_file: Path, max_retries: int = 3) -> dict[str, Any]:
+        """Async version of post_service_offering for concurrent publishing with retry logic."""
+        # Load the data file
+        data = self.load_data_file(data_file)
+
+        # Resolve file references and include content
+        base_path = data_file.parent
+        data = convert_convenience_fields_to_documents(
+            data, base_path, logo_field="logo", terms_field="terms_of_service"
         )
-        response.raise_for_status()
-        return response.json()
 
-    def post_provider(self, data_file: Path) -> dict[str, Any]:
-        """Post provider data to the backend."""
+        # Resolve file references and include content
+        data_with_content = self.resolve_file_references(data, base_path)
 
+        # Extract provider_name from directory structure
+        # Find the 'services' directory and use its parent as provider_name
+        parts = data_file.parts
+        try:
+            services_idx = parts.index("services")
+            provider_name = parts[services_idx - 1]
+            data_with_content["provider_name"] = provider_name
+
+            # Find provider directory to check status
+            provider_dir = Path(*parts[:services_idx])
+        except (ValueError, IndexError):
+            raise ValueError(
+                f"Cannot extract provider_name from path: {data_file}. "
+                f"Expected path to contain .../{{provider_name}}/services/..."
+            )
+
+        # Check provider status - skip if incomplete
+        provider_files = find_files_by_schema(provider_dir, "provider_v1")
+        if provider_files:
+            # Should only be one provider file in the directory
+            _provider_file, _format, provider_data = provider_files[0]
+            provider_status = provider_data.get("status", ProviderStatusEnum.active)
+            if provider_status == ProviderStatusEnum.incomplete:
+                return {
+                    "skipped": True,
+                    "reason": f"Provider status is '{provider_status}' - not publishing offering to backend",
+                    "name": data.get("name", "unknown"),
+                }
+
+        # Post to the endpoint using retry helper
+        context_info = f"provider: {data_with_content.get('provider_name')}"
+        return await self._post_with_retry(
+            endpoint="/publish/offering",
+            data=data_with_content,
+            entity_type="offering",
+            entity_name=data.get("name", "unknown"),
+            context_info=context_info,
+            max_retries=max_retries,
+        )
+
+    async def post_provider_async(self, data_file: Path, max_retries: int = 3) -> dict[str, Any]:
+        """Async version of post_provider for concurrent publishing with retry logic."""
         # Load the data file
         data = self.load_data_file(data_file)
 
@@ -290,22 +470,17 @@ class ServiceDataPublisher:
         # Resolve file references and include content
         data_with_content = self.resolve_file_references(data, base_path)
 
-        # Remove status field before sending to backend (backend uses is_active)
-        status = data_with_content.pop("status", ProviderStatusEnum.active)
-        # Map status to is_active: active and disabled -> True (published), incomplete -> False (not published)
-        data_with_content["is_active"] = status != ProviderStatusEnum.disabled
-
-        # Post to the endpoint
-        response = self.client.post(
-            f"{self.base_url}/publish/provider",
-            json=data_with_content,
+        # Post to the endpoint using retry helper
+        return await self._post_with_retry(
+            endpoint="/publish/provider",
+            data=data_with_content,
+            entity_type="provider",
+            entity_name=data.get("name", "unknown"),
+            max_retries=max_retries,
         )
-        response.raise_for_status()
-        return response.json()
-
-    def post_seller(self, data_file: Path) -> dict[str, Any]:
-        """Post seller data to the backend."""
 
+    async def post_seller_async(self, data_file: Path, max_retries: int = 3) -> dict[str, Any]:
+        """Async version of post_seller for concurrent publishing with retry logic."""
         # Load the data file
         data = self.load_data_file(data_file)
 
@@ -326,18 +501,14 @@ class ServiceDataPublisher:
         # Resolve file references and include content
         data_with_content = self.resolve_file_references(data, base_path)
 
-        # Remove status field before sending to backend (backend uses is_active)
-        status = data_with_content.pop("status", SellerStatusEnum.active)
-        # Map status to is_active: active and disabled -> True (published), incomplete -> False (not published)
-        data_with_content["is_active"] = status != SellerStatusEnum.disabled
-
-        # Post to the endpoint
-        response = self.client.post(
-            f"{self.base_url}/publish/seller",
-            json=data_with_content,
+        # Post to the endpoint using retry helper
+        return await self._post_with_retry(
+            endpoint="/publish/seller",
+            data=data_with_content,
+            entity_type="seller",
+            entity_name=data.get("name", "unknown"),
+            max_retries=max_retries,
         )
-        response.raise_for_status()
-        return response.json()
 
     def find_offering_files(self, data_dir: Path) -> list[Path]:
         """Find all service offering files in a directory tree."""
@@ -359,14 +530,48 @@ class ServiceDataPublisher:
         files = find_files_by_schema(data_dir, "seller_v1")
         return sorted([f[0] for f in files])
 
-    def publish_all_offerings(self, data_dir: Path) -> dict[str, Any]:
+    async def _publish_offering_task(
+        self, offering_file: Path, console: Console, semaphore: asyncio.Semaphore
+    ) -> tuple[Path, dict[str, Any] | Exception]:
+        """
+        Async task to publish a single offering with concurrency control.
+
+        Returns tuple of (offering_file, result_or_exception).
         """
-        Publish all service offerings found in a directory tree.
+        async with semaphore:  # Limit concurrent requests
+            try:
+                # Load offering data to get the name
+                data = self.load_data_file(offering_file)
+                offering_name = data.get("name", offering_file.stem)
+
+                # Publish the offering
+                result = await self.post_service_offering_async(offering_file)
+
+                # Print complete statement after publication
+                if result.get("skipped"):
+                    reason = result.get("reason", "unknown")
+                    console.print(f"  [yellow]⊘[/yellow] Skipped offering: [cyan]{offering_name}[/cyan] - {reason}")
+                else:
+                    provider_name = result.get("provider_name")
+                    console.print(
+                        f"  [green]✓[/green] Published offering: [cyan]{offering_name}[/cyan] "
+                        f"(provider: {provider_name})"
+                    )
+
+                return (offering_file, result)
+            except Exception as e:
+                data = self.load_data_file(offering_file)
+                offering_name = data.get("name", offering_file.stem)
+                console.print(f"  [red]✗[/red] Failed to publish offering: [cyan]{offering_name}[/cyan] - {str(e)}")
+                return (offering_file, e)
+
+    async def publish_all_offerings(self, data_dir: Path) -> dict[str, Any]:
+        """
+        Publish all service offerings found in a directory tree concurrently.
 
         Validates data consistency before publishing.
         Returns a summary of successes and failures.
         """
-
         # Validate all service directories first
         validator = DataValidator(data_dir, data_dir.parent / "schema")
         validation_errors = validator.validate_all_service_directories(data_dir)
@@ -386,19 +591,66 @@ class ServiceDataPublisher:
             "errors": [],
         }
 
-        for offering_file in offering_files:
-            try:
-                self.post_service_offering(offering_file)
-                results["success"] += 1
-            except Exception as e:
+        if not offering_files:
+            return results
+
+        console = Console()
+
+        # Run all offering publications concurrently with rate limiting
+        # 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:
+            if isinstance(result, Exception):
                 results["failed"] += 1
-                results["errors"].append({"file": str(offering_file), "error": str(e)})
+                results["errors"].append({"file": str(offering_file), "error": str(result)})
+            else:
+                results["success"] += 1
 
         return results
 
-    def publish_all_listings(self, data_dir: Path) -> dict[str, Any]:
+    async def _publish_listing_task(
+        self, listing_file: Path, console: Console, semaphore: asyncio.Semaphore
+    ) -> tuple[Path, dict[str, Any] | Exception]:
         """
-        Publish all service listings found in a directory tree.
+        Async task to publish a single listing with concurrency control.
+
+        Returns tuple of (listing_file, result_or_exception).
+        """
+        async with semaphore:  # Limit concurrent requests
+            try:
+                # Load listing data to get the name
+                data = self.load_data_file(listing_file)
+                listing_name = data.get("name", listing_file.stem)
+
+                # Publish the listing
+                result = await self.post_service_listing_async(listing_file)
+
+                # Print complete statement after publication
+                if result.get("skipped"):
+                    reason = result.get("reason", "unknown")
+                    console.print(f"  [yellow]⊘[/yellow] Skipped listing: [cyan]{listing_name}[/cyan] - {reason}")
+                else:
+                    service_name = result.get("service_name")
+                    provider_name = result.get("provider_name")
+                    console.print(
+                        f"  [green]✓[/green] Published listing: [cyan]{listing_name}[/cyan] "
+                        f"(service: {service_name}, provider: {provider_name})"
+                    )
+
+                return (listing_file, result)
+            except Exception as e:
+                data = self.load_data_file(listing_file)
+                listing_name = data.get("name", listing_file.stem)
+                console.print(f"  [red]✗[/red] Failed to publish listing: [cyan]{listing_file}[/cyan] - {str(e)}")
+                return (listing_file, e)
+
+    async def publish_all_listings(self, data_dir: Path) -> dict[str, Any]:
+        """
+        Publish all service listings found in a directory tree concurrently.
 
         Validates data consistency before publishing.
         Returns a summary of successes and failures.
@@ -422,19 +674,61 @@ class ServiceDataPublisher:
             "errors": [],
         }
 
-        for listing_file in listing_files:
-            try:
-                self.post_service_listing(listing_file)
-                results["success"] += 1
-            except Exception as e:
+        if not listing_files:
+            return results
+
+        console = Console()
+
+        # Run all listing publications concurrently with rate limiting
+        # 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:
+            if isinstance(result, Exception):
                 results["failed"] += 1
-                results["errors"].append({"file": str(listing_file), "error": str(e)})
+                results["errors"].append({"file": str(listing_file), "error": str(result)})
+            else:
+                results["success"] += 1
 
         return results
 
-    def publish_all_providers(self, data_dir: Path) -> dict[str, Any]:
+    async def _publish_provider_task(
+        self, provider_file: Path, console: Console, semaphore: asyncio.Semaphore
+    ) -> tuple[Path, dict[str, Any] | Exception]:
+        """
+        Async task to publish a single provider with concurrency control.
+
+        Returns tuple of (provider_file, result_or_exception).
+        """
+        async with semaphore:  # Limit concurrent requests
+            try:
+                # Load provider data to get the name
+                data = self.load_data_file(provider_file)
+                provider_name = data.get("name", provider_file.stem)
+
+                # Publish the provider
+                result = await self.post_provider_async(provider_file)
+
+                # Print complete statement after publication
+                if result.get("skipped"):
+                    reason = result.get("reason", "unknown")
+                    console.print(f"  [yellow]⊘[/yellow] Skipped provider: [cyan]{provider_name}[/cyan] - {reason}")
+                else:
+                    console.print(f"  [green]✓[/green] Published provider: [cyan]{provider_name}[/cyan]")
+
+                return (provider_file, result)
+            except Exception as e:
+                data = self.load_data_file(provider_file)
+                provider_name = data.get("name", provider_file.stem)
+                console.print(f"  [red]✗[/red] Failed to publish provider: [cyan]{provider_name}[/cyan] - {str(e)}")
+                return (provider_file, e)
+
+    async def publish_all_providers(self, data_dir: Path) -> dict[str, Any]:
         """
-        Publish all providers found in a directory tree.
+        Publish all providers found in a directory tree concurrently.
 
         Returns a summary of successes and failures.
         """
@@ -446,19 +740,61 @@ class ServiceDataPublisher:
             "errors": [],
         }
 
-        for provider_file in provider_files:
-            try:
-                self.post_provider(provider_file)
-                results["success"] += 1
-            except Exception as e:
+        if not provider_files:
+            return results
+
+        console = Console()
+
+        # Run all provider publications concurrently with rate limiting
+        # 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:
+            if isinstance(result, Exception):
                 results["failed"] += 1
-                results["errors"].append({"file": str(provider_file), "error": str(e)})
+                results["errors"].append({"file": str(provider_file), "error": str(result)})
+            else:
+                results["success"] += 1
 
         return results
 
-    def publish_all_sellers(self, data_dir: Path) -> dict[str, Any]:
+    async def _publish_seller_task(
+        self, seller_file: Path, console: Console, semaphore: asyncio.Semaphore
+    ) -> tuple[Path, dict[str, Any] | Exception]:
         """
-        Publish all sellers found in a directory tree.
+        Async task to publish a single seller with concurrency control.
+
+        Returns tuple of (seller_file, result_or_exception).
+        """
+        async with semaphore:  # Limit concurrent requests
+            try:
+                # Load seller data to get the name
+                data = self.load_data_file(seller_file)
+                seller_name = data.get("name", seller_file.stem)
+
+                # Publish the seller
+                result = await self.post_seller_async(seller_file)
+
+                # Print complete statement after publication
+                if result.get("skipped"):
+                    reason = result.get("reason", "unknown")
+                    console.print(f"  [yellow]⊘[/yellow] Skipped seller: [cyan]{seller_name}[/cyan] - {reason}")
+                else:
+                    console.print(f"  [green]✓[/green] Published seller: [cyan]{seller_name}[/cyan]")
+
+                return (seller_file, result)
+            except Exception as e:
+                data = self.load_data_file(seller_file)
+                seller_name = data.get("name", seller_file.stem)
+                console.print(f"  [red]✗[/red] Failed to publish seller: [cyan]{seller_name}[/cyan] - {str(e)}")
+                return (seller_file, e)
+
+    async def publish_all_sellers(self, data_dir: Path) -> dict[str, Any]:
+        """
+        Publish all sellers found in a directory tree concurrently.
 
         Returns a summary of successes and failures.
         """
@@ -470,17 +806,28 @@ class ServiceDataPublisher:
             "errors": [],
         }
 
-        for seller_file in seller_files:
-            try:
-                self.post_seller(seller_file)
-                results["success"] += 1
-            except Exception as e:
+        if not seller_files:
+            return results
+
+        console = Console()
+
+        # Run all seller publications concurrently with rate limiting
+        # 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:
+            if isinstance(result, Exception):
                 results["failed"] += 1
-                results["errors"].append({"file": str(seller_file), "error": str(e)})
+                results["errors"].append({"file": str(seller_file), "error": str(result)})
+            else:
+                results["success"] += 1
 
         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.
 
@@ -512,7 +859,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"]
@@ -529,9 +876,25 @@ class ServiceDataPublisher:
 
         return all_results
 
+    async def aclose(self):
+        """Close HTTP client asynchronously."""
+        await self.async_client.aclose()
+
     def close(self):
-        """Close the HTTP client."""
-        self.client.close()
+        """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."""
@@ -594,8 +957,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 = {
@@ -682,14 +1045,14 @@ def publish_providers(
             if data_path.is_file():
                 console.print(f"[blue]Publishing provider:[/blue] {data_path}")
                 console.print(f"[blue]Backend URL:[/blue] {os.getenv('UNITYSVC_BASE_URL', 'N/A')}\n")
-                result = publisher.post_provider(data_path)
+                result = asyncio.run(publisher.post_provider_async(data_path))
                 console.print("[green]✓[/green] Provider published successfully!")
                 console.print(f"[cyan]Response:[/cyan] {json.dumps(result, indent=2)}")
             # Handle directory
             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]")
@@ -741,14 +1104,14 @@ def publish_sellers(
             if data_path.is_file():
                 console.print(f"[blue]Publishing seller:[/blue] {data_path}")
                 console.print(f"[blue]Backend URL:[/blue] {os.getenv('UNITYSVC_BASE_URL', 'N/A')}\n")
-                result = publisher.post_seller(data_path)
+                result = asyncio.run(publisher.post_seller_async(data_path))
                 console.print("[green]✓[/green] Seller published successfully!")
                 console.print(f"[cyan]Response:[/cyan] {json.dumps(result, indent=2)}")
             # Handle directory
             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']}")
@@ -798,14 +1161,14 @@ def publish_offerings(
             if data_path.is_file():
                 console.print(f"[blue]Publishing service offering:[/blue] {data_path}")
                 console.print(f"[blue]Backend URL:[/blue] {os.getenv('UNITYSVC_BASE_URL', 'N/A')}\n")
-                result = publisher.post_service_offering(data_path)
+                result = asyncio.run(publisher.post_service_offering_async(data_path))
                 console.print("[green]✓[/green] Service offering published successfully!")
                 console.print(f"[cyan]Response:[/cyan] {json.dumps(result, indent=2)}")
             # 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']}")
@@ -856,14 +1219,14 @@ def publish_listings(
             if data_path.is_file():
                 console.print(f"[blue]Publishing service listing:[/blue] {data_path}")
                 console.print(f"[blue]Backend URL:[/blue] {os.getenv('UNITYSVC_BASE_URL', 'N/A')}\n")
-                result = publisher.post_service_listing(data_path)
+                result = asyncio.run(publisher.post_service_listing_async(data_path))
                 console.print("[green]✓[/green] Service listing published successfully!")
                 console.print(f"[cyan]Response:[/cyan] {json.dumps(result, indent=2)}")
             # Handle directory
             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']}")