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

unitysvc_services/query.py

@@ -31,7 +31,9 @@ class ServiceDataQuery:
                 "Backend URL not provided. Use --backend-url or set UNITYSVC_BACKEND_URL env var."
             )
         if not api_key:
-            raise ValueError("API key not provided. Use --api-key or set UNITYSVC_API_KEY env var.")
+            raise ValueError(
+                "API key not provided. Use --api-key or set UNITYSVC_API_KEY env var."
+            )
 
         self.base_url = base_url.rstrip("/")
         self.api_key = api_key
@@ -45,28 +47,28 @@ class ServiceDataQuery:
 
     def list_service_offerings(self) -> list[dict[str, Any]]:
         """List all service offerings from the backend."""
-        response = self.client.get(f"{self.base_url}/publish/service_offering")
+        response = self.client.get(f"{self.base_url}/publish/service_offerings")
         response.raise_for_status()
         result = response.json()
         return result.get("data", result) if isinstance(result, dict) else result
 
     def list_service_listings(self) -> list[dict[str, Any]]:
         """List all service listings from the backend."""
-        response = self.client.get(f"{self.base_url}/services/")
+        response = self.client.get(f"{self.base_url}/publish/services")
         response.raise_for_status()
         result = response.json()
         return result.get("data", result) if isinstance(result, dict) else result
 
     def list_providers(self) -> list[dict[str, Any]]:
         """List all providers from the backend."""
-        response = self.client.get(f"{self.base_url}/providers/")
+        response = self.client.get(f"{self.base_url}/publish/providers")
         response.raise_for_status()
         result = response.json()
         return result.get("data", result) if isinstance(result, dict) else result
 
     def list_sellers(self) -> list[dict[str, Any]]:
         """List all sellers from the backend."""
-        response = self.client.get(f"{self.base_url}/sellers/")
+        response = self.client.get(f"{self.base_url}/publish/sellers")
         response.raise_for_status()
         result = response.json()
         return result.get("data", result) if isinstance(result, dict) else result
@@ -281,12 +283,16 @@ def query_offerings(
                         )
 
                     console.print(table)
-                    console.print(f"\n[green]Total:[/green] {len(offerings)} service offering(s)")
+                    console.print(
+                        f"\n[green]Total:[/green] {len(offerings)} service offering(s)"
+                    )
     except ValueError as e:
         console.print(f"[red]✗[/red] {e}", style="bold red")
         raise typer.Exit(code=1)
     except Exception as e:
-        console.print(f"[red]✗[/red] Failed to query service offerings: {e}", style="bold red")
+        console.print(
+            f"[red]✗[/red] Failed to query service offerings: {e}", style="bold red"
+        )
         raise typer.Exit(code=1)
 
 
@@ -330,7 +336,9 @@ def query_listings(
                     table.add_column("Interfaces")
 
                     for listing in listings:
-                        interfaces_count = len(listing.get("user_access_interfaces", []))
+                        interfaces_count = len(
+                            listing.get("user_access_interfaces", [])
+                        )
                         table.add_row(
                             str(listing.get("id", "N/A")),
                             str(listing.get("service_id", "N/A")),
@@ -340,12 +348,16 @@ def query_listings(
                         )
 
                     console.print(table)
-                    console.print(f"\n[green]Total:[/green] {len(listings)} service listing(s)")
+                    console.print(
+                        f"\n[green]Total:[/green] {len(listings)} service listing(s)"
+                    )
     except ValueError as e:
         console.print(f"[red]✗[/red] {e}", style="bold red")
         raise typer.Exit(code=1)
     except Exception as e:
-        console.print(f"[red]✗[/red] Failed to query service listings: {e}", style="bold red")
+        console.print(
+            f"[red]✗[/red] Failed to query service listings: {e}", style="bold red"
+        )
         raise typer.Exit(code=1)
 
 
@@ -401,12 +413,16 @@ def query_interfaces(
                         )
 
                     console.print(table)
-                    console.print(f"\n[green]Total:[/green] {data.get('count', 0)} access interface(s)")
+                    console.print(
+                        f"\n[green]Total:[/green] {data.get('count', 0)} access interface(s)"
+                    )
     except ValueError as e:
         console.print(f"[red]✗[/red] {e}", style="bold red")
         raise typer.Exit(code=1)
     except Exception as e:
-        console.print(f"[red]✗[/red] Failed to query access interfaces: {e}", style="bold red")
+        console.print(
+            f"[red]✗[/red] Failed to query access interfaces: {e}", style="bold red"
+        )
         raise typer.Exit(code=1)
 
 
@@ -462,7 +478,9 @@ def query_documents(
                         )
 
                     console.print(table)
-                    console.print(f"\n[green]Total:[/green] {data.get('count', 0)} document(s)")
+                    console.print(
+                        f"\n[green]Total:[/green] {data.get('count', 0)} document(s)"
+                    )
     except ValueError as e:
         console.print(f"[red]✗[/red] {e}", style="bold red")
         raise typer.Exit(code=1)

unitysvc_services/update.py

@@ -251,8 +251,13 @@ def update_listing(
     if seller_name:
         field_filter["seller_name"] = seller_name
 
+    # Convert field_filter dict to tuple for caching
+    field_filter_tuple = tuple(sorted(field_filter.items())) if field_filter else None
+
     # Find listing files matching criteria
-    listing_files = find_files_by_schema(data_dir, "listing_v1", path_filter=service_name, field_filter=field_filter)
+    listing_files = find_files_by_schema(
+        data_dir, "listing_v1", path_filter=service_name, field_filter=field_filter_tuple
+    )
 
     if not listing_files:
         console.print(

unitysvc_services/utils.py

@@ -2,6 +2,7 @@
 
 import json
 import tomllib
+from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
@@ -54,23 +55,27 @@ def write_data_file(file_path: Path, data: dict[str, Any], format: str) -> None:
         raise ValueError(f"Unsupported format: {format}")
 
 
-def find_data_files(data_dir: Path, extensions: list[str] | None = None) -> list[Path]:
+@lru_cache(maxsize=128)
+def find_data_files(
+    data_dir: Path, extensions: tuple[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"])
+        extensions: Tuple of extensions to search for (default: ("json", "toml"))
 
     Returns:
         List of Path objects for matching files
     """
     if extensions is None:
-        extensions = ["json", "toml"]
+        extensions = ("json", "toml")
 
     data_files: list[Path] = []
     for ext in extensions:
         data_files.extend(data_dir.rglob(f"*.{ext}"))
+
     return data_files
 
 
@@ -103,11 +108,12 @@ def find_file_by_schema_and_name(
     return None
 
 
+@lru_cache(maxsize=256)
 def find_files_by_schema(
     data_dir: Path,
     schema: str,
     path_filter: str | None = None,
-    field_filter: dict[str, Any] | None = None,
+    field_filter: tuple[tuple[str, Any], ...] | None = None,
 ) -> list[tuple[Path, str, dict[str, Any]]]:
     """
     Find all data files matching a schema with optional filters.
@@ -116,7 +122,7 @@ def find_files_by_schema(
         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
+        field_filter: Optional tuple of (key, value) pairs to filter by
 
     Returns:
         List of tuples (file_path, format, data) for matching files
@@ -124,6 +130,9 @@ def find_files_by_schema(
     data_files = find_data_files(data_dir)
     matching_files: list[tuple[Path, str, dict[str, Any]]] = []
 
+    # Convert field_filter tuple back to dict for filtering
+    field_filter_dict = dict(field_filter) if field_filter else None
+
     for data_file in data_files:
         try:
             # Apply path filter
@@ -137,8 +146,8 @@ def find_files_by_schema(
                 continue
 
             # Apply field filters
-            if field_filter:
-                if not all(data.get(k) == v for k, v in field_filter.items()):
+            if field_filter_dict:
+                if not all(data.get(k) == v for k, v in field_filter_dict.items()):
                     continue
 
             matching_files.append((data_file, file_format, data))
@@ -199,7 +208,9 @@ def resolve_provider_name(file_path: Path) -> str | None:
     return None
 
 
-def resolve_service_name_for_listing(listing_file: Path, listing_data: dict[str, Any]) -> str | 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.
 
@@ -238,3 +249,94 @@ def resolve_service_name_for_listing(listing_file: Path, listing_data: dict[str,
 
     # Otherwise, return None (either no service files or multiple service files)
     return None
+
+
+def convert_convenience_fields_to_documents(
+    data: dict[str, Any],
+    base_path: Path,
+    *,
+    logo_field: str = "logo",
+    terms_field: str | None = "terms_of_service",
+) -> dict[str, Any]:
+    """
+    Convert convenience fields (logo, terms_of_service) to Document objects.
+
+    This utility function converts file paths or URLs in convenience fields
+    to proper Document structures that can be stored in the backend.
+
+    Args:
+        data: Data dictionary containing potential convenience fields
+        base_path: Base path for resolving relative file paths
+        logo_field: Name of the logo field (default: "logo")
+        terms_field: Name of the terms of service field (default: "terms_of_service", None to skip)
+
+    Returns:
+        Updated data dictionary with convenience fields converted to documents list
+
+    Example:
+        >>> data = {"logo": "assets/logo.png", "documents": []}
+        >>> result = convert_convenience_fields_to_documents(data, Path("/data/provider"))
+        >>> # Result will have logo removed and added to documents list
+    """
+    # Initialize documents list if not present
+    if "documents" not in data or data["documents"] is None:
+        data["documents"] = []
+
+    # Helper to determine MIME type from file path/URL
+    def get_mime_type(path_or_url: str) -> str:
+        path_lower = path_or_url.lower()
+        if path_lower.endswith((".png", ".jpg", ".jpeg")):
+            return "png" if ".png" in path_lower else "jpeg"
+        elif path_lower.endswith(".svg"):
+            return "svg"
+        elif path_lower.endswith(".pdf"):
+            return "pdf"
+        elif path_lower.endswith(".md"):
+            return "markdown"
+        else:
+            # Default to URL if it looks like a URL, otherwise markdown
+            return "url" if path_or_url.startswith("http") else "markdown"
+
+    # Convert logo field
+    if logo_field in data and data[logo_field]:
+        logo_value = data[logo_field]
+        logo_doc: dict[str, Any] = {
+            "title": "Company Logo",
+            "category": "logo",
+            "mime_type": get_mime_type(str(logo_value)),
+            "is_public": True,
+        }
+
+        # Check if it's a URL or file path
+        if str(logo_value).startswith("http"):
+            logo_doc["external_url"] = str(logo_value)
+        else:
+            # It's a file path - will be resolved by resolve_file_references
+            logo_doc["file_path"] = str(logo_value)
+
+        data["documents"].append(logo_doc)
+        # Remove the convenience field
+        del data[logo_field]
+
+    # Convert terms_of_service field if specified
+    if terms_field and terms_field in data and data[terms_field]:
+        terms_value = data[terms_field]
+        terms_doc: dict[str, Any] = {
+            "title": "Terms of Service",
+            "category": "terms_of_service",
+            "mime_type": get_mime_type(str(terms_value)),
+            "is_public": True,
+        }
+
+        # Check if it's a URL or file path
+        if str(terms_value).startswith("http"):
+            terms_doc["external_url"] = str(terms_value)
+        else:
+            # It's a file path - will be resolved by resolve_file_references
+            terms_doc["file_path"] = str(terms_value)
+
+        data["documents"].append(terms_doc)
+        # Remove the convenience field
+        del data[terms_field]
+
+    return data

unitysvc_services/validator.py

@@ -13,6 +13,8 @@ from jinja2 import Environment, TemplateSyntaxError
 from jsonschema.validators import Draft7Validator
 from rich.console import Console
 
+import unitysvc_services
+
 
 class DataValidationError(Exception):
     """Exception raised when data validation fails."""
@@ -58,12 +60,16 @@ class DataValidator:
                 if "anyOf" in obj:
                     any_of = obj["anyOf"]
                     # Count non-null items for the check
-                    non_null_items = [item for item in any_of if item.get("type") != "null"]
+                    non_null_items = [
+                        item for item in any_of if item.get("type") != "null"
+                    ]
                     has_plain_string = any(
-                        item.get("type") == "string" and "format" not in item for item in non_null_items
+                        item.get("type") == "string" and "format" not in item
+                        for item in non_null_items
                     )
                     has_uri_string = any(
-                        item.get("type") == "string" and item.get("format") == "uri" for item in non_null_items
+                        item.get("type") == "string" and item.get("format") == "uri"
+                        for item in non_null_items
                     )
 
                     # Check for Union[str, HttpUrl] or Union[str, HttpUrl, None]
@@ -78,7 +84,9 @@ class DataValidator:
 
                 # Check other schema structures
                 for key, value in obj.items():
-                    if key not in ["properties", "anyOf"] and isinstance(value, dict | list):
+                    if key not in ["properties", "anyOf"] and isinstance(
+                        value, dict | list
+                    ):
                         traverse_schema(value, path)
 
             elif isinstance(obj, list):
@@ -88,7 +96,9 @@ class DataValidator:
         traverse_schema(schema)
         return union_fields
 
-    def validate_file_references(self, data: dict[str, Any], file_path: Path, union_fields: set[str]) -> list[str]:
+    def validate_file_references(
+        self, data: dict[str, Any], file_path: Path, union_fields: set[str]
+    ) -> list[str]:
         """
         Validate that file references in Union[str, HttpUrl] fields exist.
 
@@ -110,7 +120,9 @@ class DataValidator:
                     ):
                         # Empty string is not a valid file reference
                         if value == "":
-                            errors.append(f"Empty string in field '{new_path}' is not a valid file reference or URL")
+                            errors.append(
+                                f"Empty string in field '{new_path}' is not a valid file reference or URL"
+                            )
                         # It's a file reference, must be relative path
                         elif Path(value).is_absolute():
                             errors.append(
@@ -139,6 +151,14 @@ class DataValidator:
                                 f"File path '{value}' in field '{new_path}' "
                                 f"must be a relative path, not an absolute path"
                             )
+                        # Check that the file exists
+                        else:
+                            referenced_file = file_path.parent / value
+                            if not referenced_file.exists():
+                                errors.append(
+                                    f"File reference '{value}' in field '{new_path}' "
+                                    f"does not exist at {referenced_file}"
+                                )
 
                     # Recurse into nested objects
                     if isinstance(value, dict | list):
@@ -152,7 +172,9 @@ class DataValidator:
         check_field(data, str(file_path))
         return errors
 
-    def validate_name_consistency(self, data: dict[str, Any], file_path: Path, schema_name: str) -> list[str]:
+    def validate_name_consistency(
+        self, data: dict[str, Any], file_path: Path, schema_name: str
+    ) -> list[str]:
         """Validate that the name field matches the directory name."""
         errors: list[str] = []
 
@@ -177,7 +199,9 @@ class DataValidator:
         elif file_path.name in ["service.json", "service.toml"]:
             # For service.json, the service directory should match the service name
             service_directory_name = file_path.parent.name
-            if self._normalize_name(name_value) != self._normalize_name(service_directory_name):
+            if self._normalize_name(name_value) != self._normalize_name(
+                service_directory_name
+            ):
                 normalized_name = self._normalize_name(name_value)
                 errors.append(
                     f"Service name '{name_value}' does not match "
@@ -196,7 +220,9 @@ class DataValidator:
         normalized = normalized.strip("-")
         return normalized
 
-    def load_data_file(self, file_path: Path) -> tuple[dict[str, Any] | None, list[str]]:
+    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] = []
 
@@ -211,7 +237,9 @@ class DataValidator:
                 return None, [f"Unsupported file format: {file_path.suffix}"]
             return data, errors
         except Exception as e:
-            format_name = {".json": "JSON", ".toml": "TOML"}.get(file_path.suffix, "data")
+            format_name = {".json": "JSON", ".toml": "TOML"}.get(
+                file_path.suffix, "data"
+            )
             return None, [f"Failed to parse {format_name}: {e}"]
 
     def validate_data_file(self, file_path: Path) -> tuple[bool, list[str]]:
@@ -240,13 +268,17 @@ class DataValidator:
 
         # Validate against schema with format checking enabled
         try:
-            validator = Draft7Validator(schema, format_checker=Draft7Validator.FORMAT_CHECKER)
+            validator = Draft7Validator(
+                schema, format_checker=Draft7Validator.FORMAT_CHECKER
+            )
             validator.check_schema(schema)  # Validate the schema itself
             validation_errors = list(validator.iter_errors(data))
             for error in validation_errors:
                 errors.append(f"Schema validation error: {error.message}")
                 if error.absolute_path:
-                    errors.append(f"  Path: {'.'.join(str(p) for p in error.absolute_path)}")
+                    errors.append(
+                        f"  Path: {'.'.join(str(p) for p in error.absolute_path)}"
+                    )
         except Exception as e:
             errors.append(f"Validation error: {e}")
 
@@ -314,12 +346,110 @@ class DataValidator:
                 "No seller file found. Each repository must have exactly one data file using the 'seller_v1' schema."
             )
         elif len(seller_files) > 1:
-            errors.append(f"Found {len(seller_files)} seller files, but only one is allowed per repository:")
+            errors.append(
+                f"Found {len(seller_files)} seller files, but only one is allowed per repository:"
+            )
             for seller_file in seller_files:
                 errors.append(f"  - {seller_file}")
 
         return len(errors) == 0, errors
 
+    def validate_provider_status(self) -> tuple[bool, list[str]]:
+        """
+        Validate provider status and warn about services under disabled/incomplete providers.
+
+        Returns tuple of (is_valid, warnings) where warnings indicate services
+        that will be affected by provider status.
+        """
+        from unitysvc_services.models.base import ProviderStatusEnum
+        from unitysvc_services.models.provider_v1 import ProviderV1
+
+        warnings: list[str] = []
+
+        # Find all provider files
+        provider_files = list(self.data_dir.glob("*/provider.*"))
+
+        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:
+                    continue
+
+                # Parse as ProviderV1
+                provider = ProviderV1.model_validate(data)
+                provider_dir = provider_file.parent
+                provider_name = provider.name
+
+                # Check if provider is not active
+                if provider.status != ProviderStatusEnum.active:
+                    # Find all services under this provider
+                    services_dir = provider_dir / "services"
+                    if services_dir.exists():
+                        service_count = len(list(services_dir.iterdir()))
+                        if service_count > 0:
+                            warnings.append(
+                                f"Provider '{provider_name}' has status '{provider.status}' but has {service_count} "
+                                f"service(s). All services under this provider will be affected."
+                            )
+
+            except Exception as e:
+                warnings.append(
+                    f"Error checking provider status in {provider_file}: {e}"
+                )
+
+        # Return True (valid) but with warnings
+        return True, warnings
+
+    def validate_seller_status(self) -> tuple[bool, list[str]]:
+        """
+        Validate seller status and warn if seller is disabled/incomplete.
+
+        Returns tuple of (is_valid, warnings) where warnings indicate seller issues.
+        """
+        from unitysvc_services.models.base import SellerStatusEnum
+        from unitysvc_services.models.seller_v1 import SellerV1
+
+        warnings: list[str] = []
+
+        # Find all seller files
+        seller_files = list(self.data_dir.glob("seller.*"))
+
+        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:
+                    continue
+
+                # Parse as SellerV1
+                seller = SellerV1.model_validate(data)
+                seller_name = seller.name
+
+                # Check if seller is not active
+                if seller.status != SellerStatusEnum.active:
+                    warnings.append(
+                        f"Seller '{seller_name}' has status '{seller.status}'. Seller will not be published to backend."
+                    )
+
+            except Exception as e:
+                warnings.append(f"Error checking seller status in {seller_file}: {e}")
+
+        # Return True (valid) but with warnings
+        return True, warnings
+
     def validate_all(self) -> dict[str, tuple[bool, list[str]]]:
         """Validate all files in the data directory."""
         results: dict[str, tuple[bool, list[str]]] = {}
@@ -332,6 +462,19 @@ class DataValidator:
         if not seller_valid:
             results["_seller_uniqueness"] = (False, seller_errors)
 
+        # Validate seller status
+        seller_status_valid, seller_warnings = self.validate_seller_status()
+        if seller_warnings:
+            results["_seller_status"] = (True, seller_warnings)  # Warnings, not errors
+
+        # Validate provider status and check for affected services
+        provider_status_valid, provider_warnings = self.validate_provider_status()
+        if provider_warnings:
+            results["_provider_status"] = (
+                True,
+                provider_warnings,
+            )  # Warnings, not errors
+
         # Find all data and MD files recursively
         for file_path in self.data_dir.rglob("*"):
             if file_path.is_file() and file_path.suffix in [".json", ".toml", ".md"]:
@@ -382,7 +525,9 @@ class DataValidator:
                 if schema == "service_v1":
                     service_name = data.get("name")
                     if not service_name:
-                        raise DataValidationError(f"Service file {file_path} missing 'name' field")
+                        raise DataValidationError(
+                            f"Service file {file_path} missing 'name' field"
+                        )
 
                     # Check for duplicate service names in same directory
                     if service_name in services:
@@ -410,7 +555,9 @@ class DataValidator:
             if service_name:
                 # If service_name is explicitly defined, it must match a service in the directory
                 if service_name not in services:
-                    available_services = ", ".join(services.keys()) if services else "none"
+                    available_services = (
+                        ", ".join(services.keys()) if services else "none"
+                    )
                     raise DataValidationError(
                         f"Listing file {listing_file} references service_name '{service_name}' "
                         f"which does not exist in the same directory.\n"
@@ -500,12 +647,30 @@ def validate(
     console.print(f"[cyan]Validating data files in:[/cyan] {data_dir}")
     console.print()
 
+    # Get schema directory from installed package
+    schema_dir = Path(unitysvc_services.__file__).parent / "schema"
+
     # Create validator and run validation
-    validator = DataValidator(data_dir, data_dir.parent / "schema")
-    validation_errors = validator.validate_all_service_directories(data_dir)
+    validator = DataValidator(data_dir, schema_dir)
+
+    # Run comprehensive validation (schema, file references, etc.)
+    all_results = validator.validate_all()
+    validation_errors = []
+
+    # Collect all errors from validate_all()
+    for file_path, (is_valid, errors) in all_results.items():
+        if not is_valid and errors:
+            for error in errors:
+                validation_errors.append(f"{file_path}: {error}")
+
+    # Also run service directory validation (service/listing relationships)
+    directory_errors = validator.validate_all_service_directories(data_dir)
+    validation_errors.extend(directory_errors)
 
     if validation_errors:
-        console.print(f"[red]✗ Validation failed with {len(validation_errors)} error(s):[/red]")
+        console.print(
+            f"[red]✗ Validation failed with {len(validation_errors)} error(s):[/red]"
+        )
         console.print()
         for i, error in enumerate(validation_errors, 1):
             console.print(f"[red]{i}.[/red] {error}")

{unitysvc_services-0.1.0.dist-info → unitysvc_services-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-services
-Version: 0.1.0
+Version: 0.1.1
 Summary: SDK for digital service providers on UnitySVC
 Author-email: Bo Peng <bo.peng@unitysvc.com>
 Maintainer-email: Bo Peng <bo.peng@unitysvc.com>
@@ -13,6 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: typer
 Requires-Dist: pydantic
+Requires-Dist: email-validator
 Requires-Dist: jsonschema
 Requires-Dist: jinja2
 Requires-Dist: rich