unitysvc-services 0.1.0__py3-none-any.whl → 0.1.4__py3-none-any.whl

unitysvc_services/api.py

@@ -0,0 +1,278 @@
+"""Base API client for UnitySVC with automatic curl fallback.
+
+This module provides the base class for all UnitySVC API clients with
+automatic network fallback from httpx to curl for systems with network
+restrictions (e.g., macOS with conda Python).
+"""
+
+import asyncio
+import json
+import os
+from typing import Any
+from urllib.parse import urlencode
+
+import httpx
+
+
+class UnitySvcAPI:
+    """Base class for UnitySVC API clients with automatic curl fallback.
+
+    Provides async HTTP GET/POST methods that try httpx first for performance,
+    then automatically fall back to curl if network restrictions are detected
+    (e.g., macOS with conda Python).
+
+    This base class can be used by:
+    - ServiceDataQuery (query/read operations)
+    - ServiceDataPublisher (publish/write operations)
+    - AdminQuery (administrative operations)
+    """
+
+    def __init__(self) -> None:
+        """Initialize API client from environment variables.
+
+        Raises:
+            ValueError: If required environment variables are not set
+        """
+        self.base_url = os.environ.get("UNITYSVC_BASE_URL")
+        if not self.base_url:
+            raise ValueError("UNITYSVC_BASE_URL environment variable not set")
+
+        self.api_key = os.environ.get("UNITYSVC_API_KEY")
+        if not self.api_key:
+            raise ValueError("UNITYSVC_API_KEY environment variable not set")
+
+        self.base_url = self.base_url.rstrip("/")
+        self.use_curl_fallback = False
+        self.client = httpx.AsyncClient(
+            headers={
+                "X-API-Key": self.api_key,
+                "Content-Type": "application/json",
+            },
+            timeout=30.0,
+        )
+
+    async def _make_request_curl(self, endpoint: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Make HTTP GET request using curl fallback (async).
+
+        Args:
+            endpoint: API endpoint path (e.g., "/publish/sellers")
+            params: Query parameters
+
+        Returns:
+            JSON response as dictionary
+
+        Raises:
+            RuntimeError: If curl command fails or returns non-200 status
+        """
+        url = f"{self.base_url}{endpoint}"
+        if params:
+            url = f"{url}?{urlencode(params)}"
+
+        cmd = [
+            "curl",
+            "-s",  # Silent mode
+            "-f",  # Fail on HTTP errors
+            "-H",
+            f"X-API-Key: {self.api_key}",
+            "-H",
+            "Accept: application/json",
+            url,
+        ]
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=30.0)
+
+            if proc.returncode != 0:
+                error_msg = stderr.decode().strip() if stderr else "Unknown error"
+                raise RuntimeError(f"HTTP request failed: {error_msg}")
+
+            output = stdout.decode().strip()
+            return json.loads(output)
+        except TimeoutError:
+            raise RuntimeError("Request timed out after 30 seconds")
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Invalid JSON response: {e}")
+
+    async def _make_post_request_curl(
+        self, endpoint: str, json_data: dict[str, Any] | None = None, params: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        """Make HTTP POST request using curl fallback (async).
+
+        Args:
+            endpoint: API endpoint path (e.g., "/admin/subscriptions")
+            json_data: JSON body data
+            params: Query parameters
+
+        Returns:
+            JSON response as dictionary
+
+        Raises:
+            RuntimeError: If curl command fails or returns non-200 status
+        """
+        url = f"{self.base_url}{endpoint}"
+        if params:
+            url = f"{url}?{urlencode(params)}"
+
+        cmd = [
+            "curl",
+            "-s",  # Silent mode
+            "-f",  # Fail on HTTP errors
+            "-X",
+            "POST",
+            "-H",
+            f"X-API-Key: {self.api_key}",
+            "-H",
+            "Content-Type: application/json",
+            "-H",
+            "Accept: application/json",
+        ]
+
+        if json_data:
+            cmd.extend(["-d", json.dumps(json_data)])
+
+        cmd.append(url)
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=30.0)
+
+            if proc.returncode != 0:
+                error_msg = stderr.decode().strip() if stderr else "Unknown error"
+                raise RuntimeError(f"HTTP request failed: {error_msg}")
+
+            output = stdout.decode().strip()
+            return json.loads(output)
+        except TimeoutError:
+            raise RuntimeError("Request timed out after 30 seconds")
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Invalid JSON response: {e}")
+
+    async def get(self, endpoint: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Make a GET request to the backend API with automatic curl fallback.
+
+        Public async utility method for making GET requests. Tries httpx first for performance,
+        automatically falls back to curl if network restrictions are detected (e.g., macOS
+        with conda Python).
+
+        Args:
+            endpoint: API endpoint path (e.g., "/publish/sellers", "/admin/documents")
+            params: Query parameters
+
+        Returns:
+            JSON response as dictionary
+
+        Raises:
+            RuntimeError: If both httpx and curl fail
+        """
+        # If we already know curl is needed, use it directly
+        if self.use_curl_fallback:
+            return await self._make_request_curl(endpoint, params)
+
+        # Try httpx first
+        try:
+            response = await self.client.get(f"{self.base_url}{endpoint}", params=params)
+            response.raise_for_status()
+            return response.json()
+        except (httpx.ConnectError, OSError):
+            # Connection failed - likely network restrictions
+            # Fall back to curl and remember this for future requests
+            self.use_curl_fallback = True
+            return await self._make_request_curl(endpoint, params)
+
+    async def post(
+        self, endpoint: str, json_data: dict[str, Any] | None = None, params: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        """Make a POST request to the backend API with automatic curl fallback.
+
+        Public async utility method for making POST requests. Tries httpx first for performance,
+        automatically falls back to curl if network restrictions are detected (e.g., macOS
+        with conda Python).
+
+        Args:
+            endpoint: API endpoint path (e.g., "/admin/subscriptions")
+            json_data: JSON body data
+            params: Query parameters
+
+        Returns:
+            JSON response as dictionary
+
+        Raises:
+            RuntimeError: If both httpx and curl fail
+        """
+        # If we already know curl is needed, use it directly
+        if self.use_curl_fallback:
+            return await self._make_post_request_curl(endpoint, json_data, params)
+
+        # Try httpx first
+        try:
+            response = await self.client.post(f"{self.base_url}{endpoint}", json=json_data, params=params)
+            response.raise_for_status()
+            return response.json()
+        except (httpx.ConnectError, OSError):
+            # Connection failed - likely network restrictions
+            # Fall back to curl and remember this for future requests
+            self.use_curl_fallback = True
+            return await self._make_post_request_curl(endpoint, json_data, params)
+
+    async def check_task(self, task_id: str, poll_interval: float = 2.0, timeout: float = 300.0) -> dict[str, Any]:
+        """Check and wait for task completion (async version).
+
+        Utility function to poll a Celery task until it completes or times out.
+        Uses the async HTTP client with curl fallback.
+
+        Args:
+            task_id: Celery task ID to poll
+            poll_interval: Seconds between status checks (default: 2.0)
+            timeout: Maximum seconds to wait (default: 300.0)
+
+        Returns:
+            Task result dictionary
+
+        Raises:
+            ValueError: If task fails or times out
+        """
+        import time
+
+        start_time = time.time()
+
+        while True:
+            elapsed = time.time() - start_time
+            if elapsed > timeout:
+                raise ValueError(f"Task {task_id} timed out after {timeout}s")
+
+            # Check task status using get() with automatic curl fallback
+            try:
+                status = await self.get(f"/tasks/{task_id}")
+            except Exception:
+                # Network error while checking status - retry
+                await asyncio.sleep(poll_interval)
+                continue
+
+            state = status.get("state", "PENDING")
+
+            # Check if task is complete
+            if status.get("status") == "completed" or state == "SUCCESS":
+                return status.get("result", {})
+            elif status.get("status") == "failed" or state == "FAILURE":
+                error = status.get("error", "Unknown error")
+                raise ValueError(f"Task {task_id} failed: {error}")
+
+            # Still processing - wait and retry
+            await asyncio.sleep(poll_interval)
+
+    async def aclose(self):
+        """Close the HTTP client."""
+        await self.client.aclose()
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.aclose()

unitysvc_services/format_data.py

@@ -1,6 +1,5 @@
 """Format command - format data files."""
 
-import os
 from pathlib import Path
 
 import typer
@@ -14,7 +13,7 @@ console = Console()
 def format_data(
     data_dir: Path | None = typer.Argument(
         None,
-        help="Directory containing data files to format (default: ./data or UNITYSVC_DATA_DIR env var)",
+        help="Directory containing data files to format (default: current directory)",
     ),
     check_only: bool = typer.Option(
         False,
@@ -35,11 +34,7 @@ def format_data(
 
     # Set data directory
     if data_dir is None:
-        data_dir_str = os.getenv("UNITYSVC_DATA_DIR")
-        if data_dir_str:
-            data_dir = Path(data_dir_str)
-        else:
-            data_dir = Path.cwd() / "data"
+        data_dir = Path.cwd()
 
     if not data_dir.is_absolute():
         data_dir = Path.cwd() / data_dir

unitysvc_services/list.py

@@ -1,6 +1,5 @@
 """List command group - list local data files."""
 
-import os
 from pathlib import Path
 
 import typer
@@ -21,25 +20,19 @@ console = Console()
 def list_providers(
     data_dir: Path | None = typer.Argument(
         None,
-        help="Directory containing provider files (default: ./data or UNITYSVC_DATA_DIR env var)",
+        help="Directory containing provider files (default: current directory)",
     ),
 ):
     """List all provider files found in the data directory."""
     # Set data directory
     if data_dir is None:
-        data_dir_str = os.getenv("UNITYSVC_DATA_DIR")
-        if data_dir_str:
-            data_dir = Path(data_dir_str)
-        else:
-            data_dir = Path.cwd() / "data"
+        data_dir = Path.cwd()
 
     if not data_dir.is_absolute():
         data_dir = Path.cwd() / data_dir
 
     if not data_dir.exists():
-        console.print(
-            f"[red]✗[/red] Data directory not found: {data_dir}", style="bold red"
-        )
+        console.print(f"[red]✗[/red] Data directory not found: {data_dir}", style="bold red")
         raise typer.Exit(code=1)
 
     console.print(f"[blue]Searching for providers in:[/blue] {data_dir}\n")
@@ -72,25 +65,19 @@ def list_providers(
 def list_sellers(
     data_dir: Path | None = typer.Argument(
         None,
-        help="Directory containing seller files (default: ./data or UNITYSVC_DATA_DIR env var)",
+        help="Directory containing seller files (default: current directory)",
     ),
 ):
     """List all seller files found in the data directory."""
     # Set data directory
     if data_dir is None:
-        data_dir_str = os.getenv("UNITYSVC_DATA_DIR")
-        if data_dir_str:
-            data_dir = Path(data_dir_str)
-        else:
-            data_dir = Path.cwd() / "data"
+        data_dir = Path.cwd()
 
     if not data_dir.is_absolute():
         data_dir = Path.cwd() / data_dir
 
     if not data_dir.exists():
-        console.print(
-            f"[red]✗[/red] Data directory not found: {data_dir}", style="bold red"
-        )
+        console.print(f"[red]✗[/red] Data directory not found: {data_dir}", style="bold red")
         raise typer.Exit(code=1)
 
     console.print(f"[blue]Searching for sellers in:[/blue] {data_dir}\n")
@@ -123,25 +110,19 @@ def list_sellers(
 def list_offerings(
     data_dir: Path | None = typer.Argument(
         None,
-        help="Directory containing service files (default: ./data or UNITYSVC_DATA_DIR env var)",
+        help="Directory containing service files (default: current directory)",
     ),
 ):
     """List all service offering files found in the data directory."""
     # Set data directory
     if data_dir is None:
-        data_dir_str = os.getenv("UNITYSVC_DATA_DIR")
-        if data_dir_str:
-            data_dir = Path(data_dir_str)
-        else:
-            data_dir = Path.cwd() / "data"
+        data_dir = Path.cwd()
 
     if not data_dir.is_absolute():
         data_dir = Path.cwd() / data_dir
 
     if not data_dir.exists():
-        console.print(
-            f"[red]✗[/red] Data directory not found: {data_dir}", style="bold red"
-        )
+        console.print(f"[red]✗[/red] Data directory not found: {data_dir}", style="bold red")
         raise typer.Exit(code=1)
 
     console.print(f"[blue]Searching for service offerings in:[/blue] {data_dir}\n")
@@ -172,34 +153,26 @@ def list_offerings(
         )
 
     console.print(table)
-    console.print(
-        f"\n[green]Total:[/green] {len(service_files)} service offering file(s)"
-    )
+    console.print(f"\n[green]Total:[/green] {len(service_files)} service offering file(s)")
 
 
 @app.command("listings")
 def list_listings(
     data_dir: Path | None = typer.Argument(
         None,
-        help="Directory containing listing files (default: ./data or UNITYSVC_DATA_DIR env var)",
+        help="Directory containing listing files (default: current directory)",
     ),
 ):
     """List all service listing files found in the data directory."""
     # Set data directory
     if data_dir is None:
-        data_dir_str = os.getenv("UNITYSVC_DATA_DIR")
-        if data_dir_str:
-            data_dir = Path(data_dir_str)
-        else:
-            data_dir = Path.cwd() / "data"
+        data_dir = Path.cwd()
 
     if not data_dir.is_absolute():
         data_dir = Path.cwd() / data_dir
 
     if not data_dir.exists():
-        console.print(
-            f"[red]✗[/red] Data directory not found: {data_dir}", style="bold red"
-        )
+        console.print(f"[red]✗[/red] Data directory not found: {data_dir}", style="bold red")
         raise typer.Exit(code=1)
 
     console.print(f"[blue]Searching for service listings in:[/blue] {data_dir}\n")
@@ -240,6 +213,4 @@ def list_listings(
         )
 
     console.print(table)
-    console.print(
-        f"\n[green]Total:[/green] {len(listing_files)} service listing file(s)"
-    )
+    console.print(f"\n[green]Total:[/green] {len(listing_files)} service listing file(s)")

unitysvc_services/models/base.py

@@ -1,3 +1,4 @@
+import re
 from enum import StrEnum
 from typing import Any
 
@@ -206,6 +207,24 @@ class UpstreamStatusEnum(StrEnum):
     deprecated = "deprecated"
 
 
+class ProviderStatusEnum(StrEnum):
+    """Provider status enum."""
+
+    active = "active"
+    pending = "pending"
+    disabled = "disabled"
+    incomplete = "incomplete"  # Provider information is incomplete
+
+
+class SellerStatusEnum(StrEnum):
+    """Seller status enum."""
+
+    active = "active"
+    pending = "pending"
+    disabled = "disabled"
+    incomplete = "incomplete"  # Seller information is incomplete
+
+
 class Document(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
@@ -350,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,13 +1,14 @@
 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,
+    validate_name,
 )
 
 
@@ -30,8 +31,19 @@ class ListingV1(BaseModel):
         ),
     )
 
-    seller_name: str = Field(
-        description="Name of the seller offering this service listing"
+    seller_name: str | None = Field(default=None, description="Name of the seller offering this service listing")
+
+    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
@@ -70,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
+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
@@ -51,3 +58,17 @@ class ProviderV1(BaseModel):
     homepage: HttpUrl
     contact_email: EmailStr
     secondary_contact_email: EmailStr | None = None
+
+    # Status field to track provider state
+    status: ProviderStatusEnum = Field(
+        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)