unitysvc-services 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

unitysvc_services/models/base.py

@@ -1,3 +1,4 @@
+import re
 from enum import StrEnum
 from typing import Any
 
@@ -210,6 +211,7 @@ class ProviderStatusEnum(StrEnum):
     """Provider status enum."""
 
     active = "active"
+    pending = "pending"
     disabled = "disabled"
     incomplete = "incomplete"  # Provider information is incomplete
 
@@ -218,6 +220,7 @@ class SellerStatusEnum(StrEnum):
     """Seller status enum."""
 
     active = "active"
+    pending = "pending"
     disabled = "disabled"
     incomplete = "incomplete"  # Seller information is incomplete
 
@@ -366,3 +369,123 @@ class Pricing(BaseModel):
 
     # Optional reference to upstream pricing
     reference: str | None = Field(default=None, description="Reference URL to upstream pricing")
+
+
+def validate_name(name: str, entity_type: str, display_name: str | None = None, *, allow_slash: bool = False) -> str:
+    """
+    Validate that a name field uses valid identifiers.
+
+    Name format rules:
+    - Only letters (upper/lowercase), numbers, dots, dashes, and underscores allowed
+    - If allow_slash=True, slashes are also allowed for hierarchical names
+    - Must start and end with alphanumeric characters (not special characters)
+    - Cannot have consecutive slashes (when allow_slash=True)
+    - Cannot be empty
+
+    Args:
+        name: The name value to validate
+        entity_type: Type of entity (provider, seller, service, listing) for error messages
+        display_name: Optional display name to suggest a valid name from
+        allow_slash: Whether to allow slashes for hierarchical names (default: False)
+
+    Returns:
+        The validated name (unchanged if valid)
+
+    Raises:
+        ValueError: If the name doesn't match the required pattern
+
+    Examples:
+        Without slashes (providers, sellers):
+            - name='amazon-bedrock' or name='Amazon-Bedrock'
+            - name='fireworks.ai' or name='Fireworks.ai'
+            - name='llama-3.1' or name='Llama-3.1'
+
+        With slashes (services, listings):
+            - name='gpt-4' or name='GPT-4'
+            - name='models/gpt-4' or name='models/GPT-4'
+            - name='black-forest-labs/FLUX.1-dev'
+            - name='api/v1/completion'
+    """
+    # Build pattern based on allow_slash parameter
+    if allow_slash:
+        # Pattern: starts with alphanumeric, can contain alphanumeric/dot/dash/underscore/slash, ends with alphanumeric
+        name_pattern = r"^[a-zA-Z0-9]([a-zA-Z0-9._/-]*[a-zA-Z0-9])?$"
+        allowed_chars = "letters, numbers, dots, dashes, underscores, and slashes"
+    else:
+        # Pattern: starts with alphanumeric, can contain alphanumeric/dot/dash/underscore, ends with alphanumeric
+        name_pattern = r"^[a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?$"
+        allowed_chars = "letters, numbers, dots, dashes, and underscores"
+
+    # Check for consecutive slashes if slashes are allowed
+    if allow_slash and "//" in name:
+        raise ValueError(f"Invalid {entity_type} name '{name}'. Name cannot contain consecutive slashes.")
+
+    if not re.match(name_pattern, name):
+        # Build helpful error message
+        error_msg = (
+            f"Invalid {entity_type} name '{name}'. "
+            f"Name must contain only {allowed_chars}. "
+            f"It must start and end with an alphanumeric character.\n"
+        )
+
+        # Suggest a valid name based on display_name if available
+        if display_name:
+            suggested_name = suggest_valid_name(display_name, allow_slash=allow_slash)
+            if suggested_name and suggested_name != name:
+                error_msg += f"  Suggestion: Set name='{suggested_name}' and display_name='{display_name}'\n"
+
+        # Add appropriate examples based on allow_slash
+        if allow_slash:
+            error_msg += (
+                "  Examples:\n"
+                "    - name='gpt-4' or name='GPT-4'\n"
+                "    - name='models/gpt-4' or name='models/GPT-4'\n"
+                "    - name='black-forest-labs/FLUX.1-dev'\n"
+                "    - name='api/v1/completion'"
+            )
+        else:
+            error_msg += (
+                "  Note: Use 'display_name' field for brand names with spaces and special characters.\n"
+                "  Examples:\n"
+                "    - name='amazon-bedrock' or name='Amazon-Bedrock'\n"
+                "    - name='fireworks.ai' or name='Fireworks.ai'\n"
+                "    - name='llama-3.1' or name='Llama-3.1'"
+            )
+
+        raise ValueError(error_msg)
+
+    return name
+
+
+def suggest_valid_name(display_name: str, *, allow_slash: bool = False) -> str:
+    """
+    Suggest a valid name based on a display name.
+
+    Replaces invalid characters with hyphens and ensures it follows the naming rules.
+    Preserves the original case.
+
+    Args:
+        display_name: The display name to convert
+        allow_slash: Whether to allow slashes for hierarchical names (default: False)
+
+    Returns:
+        A suggested valid name
+    """
+    if allow_slash:
+        # Replace characters that aren't alphanumeric, dot, dash, underscore, or slash with hyphens
+        suggested = re.sub(r"[^a-zA-Z0-9._/-]+", "-", display_name)
+        # Remove leading/trailing special characters
+        suggested = suggested.strip("._/-")
+        # Collapse multiple consecutive dashes
+        suggested = re.sub(r"-+", "-", suggested)
+        # Remove consecutive slashes
+        suggested = re.sub(r"/+", "/", suggested)
+    else:
+        # Replace characters that aren't alphanumeric, dot, dash, or underscore with hyphens
+        suggested = re.sub(r"[^a-zA-Z0-9._-]+", "-", display_name)
+        # Remove leading/trailing dots, dashes, or underscores
+        suggested = suggested.strip("._-")
+        # Collapse multiple consecutive dashes
+        suggested = re.sub(r"-+", "-", suggested)
+
+    return suggested

unitysvc_services/models/listing_v1.py

@@ -1,9 +1,15 @@
 from datetime import datetime
 from typing import Any
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
-from unitysvc_services.models.base import AccessInterface, Document, ListingStatusEnum, Pricing
+from unitysvc_services.models.base import (
+    AccessInterface,
+    Document,
+    ListingStatusEnum,
+    Pricing,
+    validate_name,
+)
 
 
 class ListingV1(BaseModel):
@@ -27,10 +33,19 @@ class ListingV1(BaseModel):
 
     seller_name: str | None = Field(default=None, description="Name of the seller offering this service listing")
 
-    name: str = Field(
+    name: str | None = Field(
+        default=None,
         max_length=255,
         description="Name identifier for the service listing, default to filename",
     )
+
+    # Display name for UI (human-readable listing name)
+    display_name: str | None = Field(
+        default=None,
+        max_length=200,
+        description="Human-readable listing name (e.g., 'Premium GPT-4 Access', 'Enterprise AI Services')",
+    )
+
     # unique name for each provider, usually following upstream naming convention
     # status of the service, public, deprecated etc
     listing_status: ListingStatusEnum = Field(
@@ -67,3 +82,11 @@ class ListingV1(BaseModel):
     user_parameters_ui_schema: dict[str, Any] | None = Field(
         default=None, description="Dictionary of user parameters UI schema"
     )
+
+    @field_validator("name")
+    @classmethod
+    def validate_name_format(cls, v: str | None) -> str | None:
+        """Validate that listing name uses valid identifiers (allows slashes for hierarchical names)."""
+        if v is None:
+            return v
+        return validate_name(v, "listing", allow_slash=True)

unitysvc_services/models/provider_v1.py

@@ -1,9 +1,9 @@
 from datetime import datetime
 from typing import Any
 
-from pydantic import BaseModel, ConfigDict, EmailStr, Field, HttpUrl
+from pydantic import BaseModel, ConfigDict, EmailStr, Field, HttpUrl, field_validator
 
-from unitysvc_services.models.base import AccessInterface, Document, ProviderStatusEnum
+from unitysvc_services.models.base import AccessInterface, Document, ProviderStatusEnum, validate_name
 
 
 class ProviderV1(BaseModel):
@@ -26,6 +26,13 @@ class ProviderV1(BaseModel):
     # name of the provider should be the same as directory name
     name: str
 
+    # Display name for UI (human-readable brand name)
+    display_name: str | None = Field(
+        default=None,
+        max_length=200,
+        description="Human-readable provider name (e.g., 'Amazon Bedrock', 'Fireworks.ai')",
+    )
+
     # this field is added for convenience. It will be converted to
     # documents during importing.
     logo: str | HttpUrl | None = None
@@ -57,3 +64,11 @@ class ProviderV1(BaseModel):
         default=ProviderStatusEnum.active,
         description="Provider status: active, disabled, or incomplete",
     )
+
+    @field_validator("name")
+    @classmethod
+    def validate_name_format(cls, v: str) -> str:
+        """Validate that provider name uses URL-safe identifiers."""
+        # Note: display_name is not available in the validator context for suggesting
+        # Display name will be shown in error if user provides it
+        return validate_name(v, "provider", allow_slash=False)

unitysvc_services/models/seller_v1.py

@@ -1,8 +1,8 @@
 from datetime import datetime
 
-from pydantic import BaseModel, ConfigDict, EmailStr, Field, HttpUrl
+from pydantic import BaseModel, ConfigDict, EmailStr, Field, HttpUrl, field_validator
 
-from unitysvc_services.models.base import Document, SellerStatusEnum, SellerTypeEnum
+from unitysvc_services.models.base import Document, SellerStatusEnum, SellerTypeEnum, validate_name
 
 
 class SellerV1(BaseModel):
@@ -108,3 +108,9 @@ class SellerV1(BaseModel):
         default=False,
         description="Whether the seller has been verified (KYC/business verification)",
     )
+
+    @field_validator("name")
+    @classmethod
+    def validate_name_format(cls, v: str) -> str:
+        """Validate that seller name uses URL-safe identifiers."""
+        return validate_name(v, "seller", allow_slash=False)

unitysvc_services/models/service_v1.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from typing import Any
 
-from pydantic import BaseModel, ConfigDict, Field, HttpUrl
+from pydantic import BaseModel, ConfigDict, Field, HttpUrl, field_validator
 
 from unitysvc_services.models.base import (
     AccessInterface,
@@ -10,6 +10,7 @@ from unitysvc_services.models.base import (
     ServiceTypeEnum,
     TagEnum,
     UpstreamStatusEnum,
+    validate_name,
 )
 
 
@@ -78,3 +79,9 @@ class ServiceV1(BaseModel):
     # a list of pricing models
     #
     upstream_price: Pricing | None = Field(description="List of pricing information")
+
+    @field_validator("name")
+    @classmethod
+    def validate_name_format(cls, v: str) -> str:
+        """Validate that service name uses valid identifiers (allows slashes for hierarchical names)."""
+        return validate_name(v, "service", allow_slash=True)

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,134 @@ 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 _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.
 
-        # 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"
-        )
-
-        # 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
+        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
 
-            # 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/..."
-            )
+        Returns:
+            Response JSON from successful API call
 
-        # 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"),
-                }
+        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()
+                # 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}"
+                        )
+
+                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 +235,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 +250,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 +290,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 +383,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 +414,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 +443,48 @@ class ServiceDataPublisher:
         files = find_files_by_schema(data_dir, "seller_v1")
         return sorted([f[0] for f in files])
 
+    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).
+        """
+        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)
+
     def publish_all_offerings(self, data_dir: Path) -> dict[str, Any]:
         """
-        Publish all service offerings found in a directory tree.
+        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 +504,70 @@ 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
+        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())
+
+        # 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
 
+    async def _publish_listing_task(
+        self, listing_file: Path, console: Console, semaphore: asyncio.Semaphore
+    ) -> tuple[Path, dict[str, Any] | Exception]:
+        """
+        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)
+
     def publish_all_listings(self, data_dir: Path) -> dict[str, Any]:
         """
-        Publish all service listings found in a directory tree.
+        Publish all service listings found in a directory tree concurrently.
 
         Validates data consistency before publishing.
         Returns a summary of successes and failures.
@@ -422,19 +591,65 @@ 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
+        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())
+
+        # 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
 
+    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)
+
     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 +661,65 @@ 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
+        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())
+
+        # 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
 
+    async def _publish_seller_task(
+        self, seller_file: Path, console: Console, semaphore: asyncio.Semaphore
+    ) -> tuple[Path, dict[str, Any] | Exception]:
+        """
+        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)
+
     def publish_all_sellers(self, data_dir: Path) -> dict[str, Any]:
         """
-        Publish all sellers found in a directory tree.
+        Publish all sellers found in a directory tree concurrently.
 
         Returns a summary of successes and failures.
         """
@@ -470,13 +731,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
+        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())
+
+        # 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
 
@@ -530,8 +806,8 @@ class ServiceDataPublisher:
         return all_results
 
     def close(self):
-        """Close the HTTP client."""
-        self.client.close()
+        """Close HTTP client."""
+        asyncio.run(self.async_client.aclose())
 
     def __enter__(self):
         """Context manager entry."""
@@ -682,7 +958,7 @@ 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
@@ -741,7 +1017,7 @@ 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
@@ -798,7 +1074,7 @@ 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
@@ -856,7 +1132,7 @@ 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

unitysvc_services/query.py

@@ -421,7 +421,7 @@ def query_offerings(
         help="Output format: table, json",
     ),
     fields: str = typer.Option(
-        "id,service_name,service_type,provider_name,status",
+        "id,name,service_type,provider_name,status",
         "--fields",
         help=(
             "Comma-separated list of fields to display. Available fields: "
@@ -447,7 +447,7 @@ def query_offerings(
         unitysvc_services query offerings
 
         # Show only specific fields
-        unitysvc_services query offerings --fields id,service_name,status
+        unitysvc_services query offerings --fields id,name,status
 
         # Retrieve more than 100 records
         unitysvc_services query offerings --limit 500
@@ -469,7 +469,7 @@ def query_offerings(
         "provider_id",
         "status",
         "price",
-        "service_name",
+        "name",
         "service_type",
         "provider_name",
     }
@@ -578,7 +578,7 @@ def query_listings(
 
         # Show all available fields
         unitysvc_services query listings --fields \\
-            id,service_name,service_type,seller_name,listing_type,status,provider_name
+            id,name,service_name,service_type,seller_name,listing_type,status,provider_name
     """
     # Parse fields list
     field_list = [f.strip() for f in fields.split(",")]
@@ -586,6 +586,7 @@ def query_listings(
     # Define allowed fields from ServiceListingPublic model
     allowed_fields = {
         "id",
+        "name",
         "offering_id",
         "offering_status",
         "seller_id",

unitysvc_services/validator.py

@@ -205,6 +205,54 @@ class DataValidator:
         normalized = normalized.strip("-")
         return normalized
 
+    def validate_with_pydantic_model(self, data: dict[str, Any], schema_name: str) -> list[str]:
+        """
+        Validate data using Pydantic models for additional validation rules.
+
+        This complements JSON schema validation with Pydantic field validators
+        like name format validation.
+
+        Args:
+            data: The data to validate
+            schema_name: The schema name (e.g., 'provider_v1', 'seller_v1')
+
+        Returns:
+            List of validation error messages
+        """
+        from pydantic import BaseModel
+
+        from unitysvc_services.models import ListingV1, ProviderV1, SellerV1, ServiceV1
+
+        errors: list[str] = []
+
+        # Map schema names to Pydantic model classes
+        model_map: dict[str, type[BaseModel]] = {
+            "provider_v1": ProviderV1,
+            "seller_v1": SellerV1,
+            "service_v1": ServiceV1,
+            "listing_v1": ListingV1,
+        }
+
+        if schema_name not in model_map:
+            return errors  # No Pydantic model for this schema
+
+        model_class = model_map[schema_name]
+
+        try:
+            # Validate using the Pydantic model
+            model_class.model_validate(data)
+
+        except Exception as e:
+            # Extract meaningful error message from Pydantic ValidationError
+            error_msg = str(e)
+            # Pydantic errors can be verbose, try to extract just the relevant part
+            if "validation error" in error_msg.lower():
+                errors.append(f"Pydantic validation error: {error_msg}")
+            else:
+                errors.append(error_msg)
+
+        return errors
+
     def load_data_file(self, file_path: Path) -> tuple[dict[str, Any] | None, list[str]]:
         """Load data from JSON or TOML file."""
         errors: list[str] = []
@@ -259,6 +307,10 @@ class DataValidator:
         except Exception as e:
             errors.append(f"Validation error: {e}")
 
+        # Also validate using Pydantic models for additional validation rules
+        pydantic_errors = self.validate_with_pydantic_model(data, schema_name)
+        errors.extend(pydantic_errors)
+
         # Find Union[str, HttpUrl] fields and validate file references
         union_fields = self.find_union_fields(schema)
         file_ref_errors = self.validate_file_references(data, file_path, union_fields)
@@ -308,6 +360,10 @@ class DataValidator:
 
         # Find all data files with seller_v1 schema
         for file_path in self.data_dir.rglob("*"):
+            # Skip hidden directories (those starting with .)
+            if any(part.startswith(".") for part in file_path.parts):
+                continue
+
             if file_path.is_file() and file_path.suffix in [".json", ".toml"]:
                 try:
                     data, load_errors = self.load_data_file(file_path)
@@ -341,20 +397,17 @@ class DataValidator:
 
         warnings: list[str] = []
 
-        # Find all provider files
-        provider_files = list(self.data_dir.glob("*/provider.*"))
+        # Find all provider files (skip hidden directories)
+        provider_files = [
+            f for f in self.data_dir.glob("*/provider.*") if not any(part.startswith(".") for part in f.parts)
+        ]
 
         for provider_file in provider_files:
             try:
-                # Load provider data
-                data = {}
-                if provider_file.suffix == ".json":
-                    with open(provider_file, encoding="utf-8") as f:
-                        data = json.load(f)
-                elif provider_file.suffix == ".toml":
-                    with open(provider_file, "rb") as f:
-                        data = toml.load(f)
-                else:
+                # Load provider data using existing helper method
+                data, load_errors = self.load_data_file(provider_file)
+                if load_errors or data is None:
+                    warnings.append(f"Failed to load provider file {provider_file}: {load_errors}")
                     continue
 
                 # Parse as ProviderV1
@@ -391,20 +444,15 @@ class DataValidator:
 
         warnings: list[str] = []
 
-        # Find all seller files
-        seller_files = list(self.data_dir.glob("seller.*"))
+        # Find all seller files (skip hidden files)
+        seller_files = [f for f in self.data_dir.glob("seller.*") if not f.name.startswith(".")]
 
         for seller_file in seller_files:
             try:
-                # Load seller data
-                data = {}
-                if seller_file.suffix == ".json":
-                    with open(seller_file, encoding="utf-8") as f:
-                        data = json.load(f)
-                elif seller_file.suffix == ".toml":
-                    with open(seller_file, "rb") as f:
-                        data = toml.load(f)
-                else:
+                # Load seller data using existing helper method
+                data, load_errors = self.load_data_file(seller_file)
+                if load_errors or data is None:
+                    warnings.append(f"Failed to load seller file {seller_file}: {load_errors}")
                     continue
 
                 # Parse as SellerV1
@@ -448,8 +496,12 @@ class DataValidator:
                 provider_warnings,
             )  # Warnings, not errors
 
-        # Find all data and MD files recursively
+        # Find all data and MD files recursively, skipping hidden directories
         for file_path in self.data_dir.rglob("*"):
+            # Skip hidden directories (those starting with .)
+            if any(part.startswith(".") for part in file_path.parts):
+                continue
+
             if file_path.is_file() and file_path.suffix in [".json", ".toml", ".md"]:
                 relative_path = file_path.relative_to(self.data_dir)
 
@@ -560,6 +612,10 @@ class DataValidator:
 
         for pattern in ["*.json", "*.toml"]:
             for file_path in data_dir.rglob(pattern):
+                # Skip hidden directories (those starting with .)
+                if any(part.startswith(".") for part in file_path.parts):
+                    continue
+
                 try:
                     data, load_errors = self.load_data_file(file_path)
                     if load_errors or data is None:

{unitysvc_services-0.2.5.dist-info → unitysvc_services-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-services
-Version: 0.2.5
+Version: 0.2.7
 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.dist-info/RECORD

@@ -0,0 +1,24 @@
+unitysvc_services/__init__.py,sha256=J6F3RlZCJUVjhZoprfbrYCxe3l9ynQQbGO7pf7FyqlM,110
+unitysvc_services/cli.py,sha256=OK0IZyAckxP15jRWU_W49hl3t7XcNRtd8BoDMyRKqNM,682
+unitysvc_services/format_data.py,sha256=Jl9Vj3fRX852fHSUa5DzO-oiFQwuQHC3WMCDNIlo1Lc,5460
+unitysvc_services/list.py,sha256=QDp9BByaoeFeJxXJN9RQ-jU99mH9Guq9ampfXCbpZmI,7033
+unitysvc_services/populate.py,sha256=zkcjIy8BWuQSO7JwiRNHKgGoxQvc3ujluUQdYixdBvY,6626
+unitysvc_services/publisher.py,sha256=xQqIajb3JRDX9Qg6N94hqtT_mc0NBYbUYKKMm4zsKyE,48686
+unitysvc_services/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+unitysvc_services/query.py,sha256=x2VUnfva21-mVd-JgtChajNBgXG1AQJ6c3umCw2FNWU,24089
+unitysvc_services/scaffold.py,sha256=Y73IX8vskImxSvxDgR0mvEFuAMYnBKfttn3bjcz3jmQ,40331
+unitysvc_services/update.py,sha256=K9swocTUnqqiSgARo6GmuzTzUySSpyqqPPW4xF7ZU-g,9659
+unitysvc_services/utils.py,sha256=GN0gkVTU8fOx2G0EbqnWmx8w9eFsoPfRprPjwCyPYkE,11371
+unitysvc_services/validator.py,sha256=VAII5mu_Jdyr96v4nwXzihsoAj7DJiXN6LjhL8lGGUo,29054
+unitysvc_services/models/__init__.py,sha256=hJCc2KSZmIHlKWKE6GpLGdeVB6LIpyVUKiOKnwmKvCs,200
+unitysvc_services/models/base.py,sha256=3FdlR-_tBOFC2JbVNFNQA4-D1Lhlo5UZQh1QDgKnS_I,18293
+unitysvc_services/models/listing_v1.py,sha256=PPb9hIdWQp80AWKLxFXYBDcWXzNcDrO4v6rqt5_i2qo,3083
+unitysvc_services/models/provider_v1.py,sha256=76EK1i0hVtdx_awb00-ZMtSj4Oc9Zp4xZ-DeXmG3iTY,2701
+unitysvc_services/models/seller_v1.py,sha256=oll2ZZBPBDX8wslHrbsCKf_jIqHNte2VEj5RJ9bawR4,3520
+unitysvc_services/models/service_v1.py,sha256=Xpk-K-95M1LRqYM8nNJcll8t-lsW9Xdi2_bVbYNs8-M,3019
+unitysvc_services-0.2.7.dist-info/licenses/LICENSE,sha256=_p8V6A8OMPu2HIztn3O01v0-urZFwk0Dd3Yk_PTIlL8,1065
+unitysvc_services-0.2.7.dist-info/METADATA,sha256=8KqcRPrJwkYb9zCgT3rytQTOrmIBGm3hHctp-7VYM3A,6628
+unitysvc_services-0.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+unitysvc_services-0.2.7.dist-info/entry_points.txt,sha256=-vodnbPmo7QQmFu8jdG6sCyGRVM727w9Nhwp4Vwau_k,64
+unitysvc_services-0.2.7.dist-info/top_level.txt,sha256=GIotQj-Ro2ruR7eupM1r58PWqIHTAq647ORL7E2kneo,18
+unitysvc_services-0.2.7.dist-info/RECORD,,

unitysvc_services-0.2.5.dist-info/RECORD

@@ -1,24 +0,0 @@
-unitysvc_services/__init__.py,sha256=J6F3RlZCJUVjhZoprfbrYCxe3l9ynQQbGO7pf7FyqlM,110
-unitysvc_services/cli.py,sha256=OK0IZyAckxP15jRWU_W49hl3t7XcNRtd8BoDMyRKqNM,682
-unitysvc_services/format_data.py,sha256=Jl9Vj3fRX852fHSUa5DzO-oiFQwuQHC3WMCDNIlo1Lc,5460
-unitysvc_services/list.py,sha256=QDp9BByaoeFeJxXJN9RQ-jU99mH9Guq9ampfXCbpZmI,7033
-unitysvc_services/populate.py,sha256=zkcjIy8BWuQSO7JwiRNHKgGoxQvc3ujluUQdYixdBvY,6626
-unitysvc_services/publisher.py,sha256=s3px0i1ov6FisnnYG-gkkMHwJhnGbf-Ug225vosfxxM,35733
-unitysvc_services/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-unitysvc_services/query.py,sha256=M8-zklRYvIaLZSzmDVroZBf48OyGUa1nvhUaLzZXeuU,24092
-unitysvc_services/scaffold.py,sha256=Y73IX8vskImxSvxDgR0mvEFuAMYnBKfttn3bjcz3jmQ,40331
-unitysvc_services/update.py,sha256=K9swocTUnqqiSgARo6GmuzTzUySSpyqqPPW4xF7ZU-g,9659
-unitysvc_services/utils.py,sha256=GN0gkVTU8fOx2G0EbqnWmx8w9eFsoPfRprPjwCyPYkE,11371
-unitysvc_services/validator.py,sha256=zuFA44ezKlfUTtdJ8M2Xd7nk1Eot4HxbBksEUaIIpZs,26790
-unitysvc_services/models/__init__.py,sha256=hJCc2KSZmIHlKWKE6GpLGdeVB6LIpyVUKiOKnwmKvCs,200
-unitysvc_services/models/base.py,sha256=gm3xlcC35QNRST5ikJPhdk-dTTXoY9D_5Jxkyt8SBCU,13173
-unitysvc_services/models/listing_v1.py,sha256=8cSd91weXGpP5tX9aQg0iagi1H3gSd5WJddVhOJji3c,2421
-unitysvc_services/models/provider_v1.py,sha256=cYK5kDDmzQEnLvUC2C8dKz-ZXci7hVn3fjNrJkaSr10,2050
-unitysvc_services/models/seller_v1.py,sha256=SU4rqYAh9hE4EeUrEkqaVrLwusenV7MotPF77VcsRKo,3263
-unitysvc_services/models/service_v1.py,sha256=u16zqM3khrJoTw_v0d45tMcKXjko5k_v3w8xwUtZ6nM,2720
-unitysvc_services-0.2.5.dist-info/licenses/LICENSE,sha256=_p8V6A8OMPu2HIztn3O01v0-urZFwk0Dd3Yk_PTIlL8,1065
-unitysvc_services-0.2.5.dist-info/METADATA,sha256=G6wUb0qoOpZtYWLYnp-MfOgv3tMZWHqh-K78vAm1POI,6628
-unitysvc_services-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-unitysvc_services-0.2.5.dist-info/entry_points.txt,sha256=-vodnbPmo7QQmFu8jdG6sCyGRVM727w9Nhwp4Vwau_k,64
-unitysvc_services-0.2.5.dist-info/top_level.txt,sha256=GIotQj-Ro2ruR7eupM1r58PWqIHTAq647ORL7E2kneo,18
-unitysvc_services-0.2.5.dist-info/RECORD,,