unitysvc-services 0.1.0__py3-none-any.whl

unitysvc_services/update.py

@@ -0,0 +1,293 @@
+"""Update command group - update local data files."""
+
+import os
+from pathlib import Path
+from typing import Any
+
+import typer
+from rich.console import Console
+
+from .utils import find_file_by_schema_and_name, find_files_by_schema, write_data_file
+
+app = typer.Typer(help="Update local data files")
+console = Console()
+
+
+@app.command("offering")
+def update_offering(
+    name: str = typer.Option(
+        ...,
+        "--name",
+        "-n",
+        help="Name of the service offering to update (matches 'name' field in service file)",
+    ),
+    status: str | None = typer.Option(
+        None,
+        "--status",
+        "-s",
+        help="New upstream_status (uploading, ready, deprecated)",
+    ),
+    display_name: str | None = typer.Option(
+        None,
+        "--display-name",
+        help="New display name for the offering",
+    ),
+    description: str | None = typer.Option(
+        None,
+        "--description",
+        help="New description for the offering",
+    ),
+    version: str | None = typer.Option(
+        None,
+        "--version",
+        help="New version for the offering",
+    ),
+    data_dir: Path | None = typer.Option(
+        None,
+        "--data-dir",
+        "-d",
+        help="Directory containing data files (default: ./data or UNITYSVC_DATA_DIR env var)",
+    ),
+):
+    """
+    Update fields in a service offering's local data file.
+
+    Searches for files with schema 'service_v1' by offering name and updates the specified fields.
+
+    Allowed upstream_status values:
+      - uploading: Service is being uploaded (not ready)
+      - ready: Service is ready to be used
+      - deprecated: Service is deprecated from upstream
+    """
+    # Validate status if provided
+    if status:
+        valid_statuses = ["uploading", "ready", "deprecated"]
+        if status not in valid_statuses:
+            console.print(
+                f"[red]✗[/red] Invalid status: {status}",
+                style="bold red",
+            )
+            console.print(f"[yellow]Allowed statuses:[/yellow] {', '.join(valid_statuses)}")
+            raise typer.Exit(code=1)
+
+    # Check if any update field is provided
+    if not any([status, display_name, description, version]):
+        console.print(
+            (
+                "[red]✗[/red] No fields to update. Provide at least one of: "
+                "--status, --display-name, --description, --version"
+            ),
+            style="bold red",
+        )
+        raise typer.Exit(code=1)
+
+    # 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"
+
+    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")
+        raise typer.Exit(code=1)
+
+    console.print(f"[blue]Searching for offering:[/blue] {name}")
+    console.print(f"[blue]In directory:[/blue] {data_dir}\n")
+
+    # Find the matching offering file
+    result = find_file_by_schema_and_name(data_dir, "service_v1", "name", name)
+
+    if not result:
+        console.print(
+            f"[red]✗[/red] No offering found with name: {name}",
+            style="bold red",
+        )
+        raise typer.Exit(code=1)
+
+    matching_file, matching_format, data = result
+
+    # Update the fields
+    try:
+        updates: dict[str, tuple[Any, Any]] = {}  # field: (old_value, new_value)
+
+        if status:
+            updates["upstream_status"] = (data.get("upstream_status", "unknown"), status)
+            data["upstream_status"] = status
+
+        if display_name:
+            updates["display_name"] = (data.get("display_name", ""), display_name)
+            data["display_name"] = display_name
+
+        if description:
+            updates["description"] = (data.get("description", ""), description)
+            data["description"] = description
+
+        if version:
+            updates["version"] = (data.get("version", ""), version)
+            data["version"] = version
+
+        # Write back in same format
+        write_data_file(matching_file, data, matching_format)
+
+        console.print("[green]✓[/green] Updated offering successfully!")
+        console.print(f"[cyan]File:[/cyan] {matching_file.relative_to(data_dir)}")
+        console.print(f"[cyan]Format:[/cyan] {matching_format.upper()}\n")
+
+        for field, (old, new) in updates.items():
+            console.print(f"[cyan]{field}:[/cyan]")
+            if len(str(old)) > 60 or len(str(new)) > 60:
+                console.print(f"  [dim]Old:[/dim] {str(old)[:60]}...")
+                console.print(f"  [dim]New:[/dim] {str(new)[:60]}...")
+            else:
+                console.print(f"  [dim]Old:[/dim] {old}")
+                console.print(f"  [dim]New:[/dim] {new}")
+
+    except Exception as e:
+        console.print(
+            f"[red]✗[/red] Failed to update offering: {e}",
+            style="bold red",
+        )
+        raise typer.Exit(code=1)
+
+
+@app.command("listing")
+def update_listing(
+    service_name: str = typer.Option(
+        ...,
+        "--service-name",
+        "-n",
+        help="Name of the service (to search for listing files in service directory)",
+    ),
+    status: str | None = typer.Option(
+        None,
+        "--status",
+        "-s",
+        help=(
+            "New listing_status (unknown, upstream_ready, downstream_ready, "
+            "ready, in_service, upstream_deprecated, deprecated)"
+        ),
+    ),
+    seller_name: str | None = typer.Option(
+        None,
+        "--seller",
+        help="Seller name to filter listings (updates only matching seller's listing)",
+    ),
+    data_dir: Path | None = typer.Option(
+        None,
+        "--data-dir",
+        "-d",
+        help="Directory containing data files (default: ./data or UNITYSVC_DATA_DIR env var)",
+    ),
+):
+    """
+    Update fields in service listing(s) local data files.
+
+    Searches for files with schema 'listing_v1' in the service directory and updates the specified fields.
+
+    Allowed listing_status values:
+      - unknown: Not yet determined
+      - upstream_ready: Upstream is ready to be used
+      - downstream_ready: Downstream is ready with proper routing, logging, and billing
+      - ready: Operationally ready (with docs, metrics, and pricing)
+      - in_service: Service is in service
+      - upstream_deprecated: Service is deprecated from upstream
+      - deprecated: Service is no longer offered to users
+    """
+    # Validate status if provided
+    if status:
+        valid_statuses = [
+            "unknown",
+            "upstream_ready",
+            "downstream_ready",
+            "ready",
+            "in_service",
+            "upstream_deprecated",
+            "deprecated",
+        ]
+        if status not in valid_statuses:
+            console.print(
+                f"[red]✗[/red] Invalid status: {status}",
+                style="bold red",
+            )
+            console.print(f"[yellow]Allowed statuses:[/yellow] {', '.join(valid_statuses)}")
+            raise typer.Exit(code=1)
+
+    # Check if any update field is provided
+    if not status:
+        console.print(
+            "[red]✗[/red] No fields to update. Provide at least one of: --status",
+            style="bold red",
+        )
+        raise typer.Exit(code=1)
+
+    # 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"
+
+    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")
+        raise typer.Exit(code=1)
+
+    console.print(f"[blue]Searching for service:[/blue] {service_name}")
+    console.print(f"[blue]In directory:[/blue] {data_dir}")
+    if seller_name:
+        console.print(f"[blue]Filtering by seller:[/blue] {seller_name}")
+    console.print()
+
+    # Build field filter
+    field_filter = {}
+    if seller_name:
+        field_filter["seller_name"] = seller_name
+
+    # Find listing files matching criteria
+    listing_files = find_files_by_schema(data_dir, "listing_v1", path_filter=service_name, field_filter=field_filter)
+
+    if not listing_files:
+        console.print(
+            "[red]✗[/red] No listing files found matching criteria",
+            style="bold red",
+        )
+        raise typer.Exit(code=1)
+
+    # Update all matching listings
+    updated_count = 0
+    for listing_file, file_format, data in listing_files:
+        try:
+            old_status = data.get("listing_status", "unknown")
+            if status:
+                data["listing_status"] = status
+
+            # Write back in same format
+            write_data_file(listing_file, data, file_format)
+
+            console.print(f"[green]✓[/green] Updated: {listing_file.relative_to(data_dir)}")
+            console.print(f"  [dim]Seller: {data.get('seller_name', 'N/A')}[/dim]")
+            console.print(f"  [dim]Format: {file_format.upper()}[/dim]")
+            if status:
+                console.print(f"  [dim]Old status: {old_status} → New status: {status}[/dim]")
+            console.print()
+            updated_count += 1
+
+        except Exception as e:
+            console.print(
+                f"[red]✗[/red] Failed to update {listing_file.relative_to(data_dir)}: {e}",
+                style="bold red",
+            )
+
+    if updated_count > 0:
+        console.print(f"[green]✓[/green] Successfully updated {updated_count} listing(s)")
+    else:
+        console.print("[red]✗[/red] No listings were updated", style="bold red")
+        raise typer.Exit(code=1)

unitysvc_services/utils.py

@@ -0,0 +1,240 @@
+"""Utility functions for file handling and data operations."""
+
+import json
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+
+
+def load_data_file(file_path: Path) -> tuple[dict[str, Any], str]:
+    """
+    Load a data file (JSON or TOML) and return (data, format).
+
+    Args:
+        file_path: Path to the data file
+
+    Returns:
+        Tuple of (data dict, format string "json" or "toml")
+
+    Raises:
+        ValueError: If file format is not supported
+    """
+    if file_path.suffix == ".json":
+        with open(file_path, encoding="utf-8") as f:
+            return json.load(f), "json"
+    elif file_path.suffix == ".toml":
+        with open(file_path, "rb") as f:
+            return tomllib.load(f), "toml"
+    else:
+        raise ValueError(f"Unsupported file format: {file_path.suffix}")
+
+
+def write_data_file(file_path: Path, data: dict[str, Any], format: str) -> None:
+    """
+    Write data back to file in the specified format.
+
+    Args:
+        file_path: Path to the data file
+        data: Data dictionary to write
+        format: Format string ("json" or "toml")
+
+    Raises:
+        ValueError: If format is not supported
+    """
+    if format == "json":
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, sort_keys=True)
+            f.write("\n")
+    elif format == "toml":
+        with open(file_path, "wb") as f:
+            tomli_w.dump(data, f)
+    else:
+        raise ValueError(f"Unsupported format: {format}")
+
+
+def find_data_files(data_dir: Path, extensions: list[str] | None = None) -> list[Path]:
+    """
+    Find all data files in a directory with specified extensions.
+
+    Args:
+        data_dir: Directory to search
+        extensions: List of extensions to search for (default: ["json", "toml"])
+
+    Returns:
+        List of Path objects for matching files
+    """
+    if extensions is None:
+        extensions = ["json", "toml"]
+
+    data_files: list[Path] = []
+    for ext in extensions:
+        data_files.extend(data_dir.rglob(f"*.{ext}"))
+    return data_files
+
+
+def find_file_by_schema_and_name(
+    data_dir: Path, schema: str, name_field: str, name_value: str
+) -> tuple[Path, str, dict[str, Any]] | None:
+    """
+    Find a data file by schema type and name field value.
+
+    Args:
+        data_dir: Directory to search
+        schema: Schema identifier (e.g., "service_v1", "listing_v1")
+        name_field: Field name to match (e.g., "name", "seller_name")
+        name_value: Value to match in the name field
+
+    Returns:
+        Tuple of (file_path, format, data) if found, None otherwise
+    """
+    data_files = find_data_files(data_dir)
+
+    for data_file in data_files:
+        try:
+            data, file_format = load_data_file(data_file)
+            if data.get("schema") == schema and data.get(name_field) == name_value:
+                return data_file, file_format, data
+        except Exception:
+            # Skip files that can't be loaded
+            continue
+
+    return None
+
+
+def find_files_by_schema(
+    data_dir: Path,
+    schema: str,
+    path_filter: str | None = None,
+    field_filter: dict[str, Any] | None = None,
+) -> list[tuple[Path, str, dict[str, Any]]]:
+    """
+    Find all data files matching a schema with optional filters.
+
+    Args:
+        data_dir: Directory to search
+        schema: Schema identifier (e.g., "service_v1", "listing_v1")
+        path_filter: Optional string that must be in the file path
+        field_filter: Optional dict of field:value pairs to filter by
+
+    Returns:
+        List of tuples (file_path, format, data) for matching files
+    """
+    data_files = find_data_files(data_dir)
+    matching_files: list[tuple[Path, str, dict[str, Any]]] = []
+
+    for data_file in data_files:
+        try:
+            # Apply path filter
+            if path_filter and path_filter not in str(data_file):
+                continue
+
+            data, file_format = load_data_file(data_file)
+
+            # Check schema
+            if data.get("schema") != schema:
+                continue
+
+            # Apply field filters
+            if field_filter:
+                if not all(data.get(k) == v for k, v in field_filter.items()):
+                    continue
+
+            matching_files.append((data_file, file_format, data))
+
+        except Exception:
+            # Skip files that can't be loaded
+            continue
+
+    return matching_files
+
+
+def resolve_provider_name(file_path: Path) -> str | None:
+    """
+    Resolve the provider name from the file path.
+
+    The provider name is determined by the directory structure:
+    - For service offerings: <provider_name>/services/<service_name>/service.{json,toml}
+    - For service listings: <provider_name>/services/<service_name>/listing-*.{json,toml}
+
+    Args:
+        file_path: Path to the service offering or listing file
+
+    Returns:
+        Provider name if found in directory structure, None otherwise
+    """
+    # Check if file is under a "services" directory
+    parts = file_path.parts
+
+    try:
+        # Find the "services" directory in the path
+        services_idx = parts.index("services")
+
+        # Provider name is the directory before "services"
+        if services_idx > 0:
+            provider_dir = parts[services_idx - 1]
+
+            # The provider directory should contain a provider data file
+            # Get the full path to the provider directory
+            provider_path = Path(*parts[:services_idx])
+
+            # Look for provider data file to validate and get the actual provider name
+            for data_file in find_data_files(provider_path):
+                try:
+                    # Only check files in the provider directory itself, not subdirectories
+                    if data_file.parent == provider_path:
+                        data, _file_format = load_data_file(data_file)
+                        if data.get("schema") == "provider_v1":
+                            return data.get("name")
+                except Exception:
+                    continue
+
+            # Fallback to directory name if no provider file found
+            return provider_dir
+    except (ValueError, IndexError):
+        # "services" not in path or invalid structure
+        pass
+
+    return None
+
+
+def resolve_service_name_for_listing(listing_file: Path, listing_data: dict[str, Any]) -> str | None:
+    """
+    Resolve the service name for a listing file.
+
+    Rules:
+    1. If service_name is defined in listing_data, return it
+    2. Otherwise, find the only service offering in the same directory and return its name
+
+    Args:
+        listing_file: Path to the listing file
+        listing_data: Listing data dictionary
+
+    Returns:
+        Service name if found, None otherwise
+    """
+    # Rule 1: If service_name is already defined, use it
+    if "service_name" in listing_data and listing_data["service_name"]:
+        return listing_data["service_name"]
+
+    # Rule 2: Find the only service offering in the same directory
+    listing_dir = listing_file.parent
+
+    # Find all service offering files in the same directory
+    service_files: list[tuple[Path, str, dict[str, Any]]] = []
+    for data_file in find_data_files(listing_dir):
+        try:
+            data, file_format = load_data_file(data_file)
+            if data.get("schema") == "service_v1":
+                service_files.append((data_file, file_format, data))
+        except Exception:
+            continue
+
+    # If there's exactly one service file, use its name
+    if len(service_files) == 1:
+        _service_file, _service_format, service_data = service_files[0]
+        return service_data.get("name")
+
+    # Otherwise, return None (either no service files or multiple service files)
+    return None