unitysvc-core 0.2.29__tar.gz → 0.2.31__tar.gz

{unitysvc_core-0.2.29/src/unitysvc_core.egg-info → unitysvc_core-0.2.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-core
-Version: 0.2.29
+Version: 0.2.31
 Summary: Shared data models and validation helpers for UnitySVC packages
 Author-email: Bo Peng <bo.peng@unitysvc.com>
 Maintainer-email: Bo Peng <bo.peng@unitysvc.com>

{unitysvc_core-0.2.29 → unitysvc_core-0.2.31}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unitysvc-core"
-version = "0.2.29"
+version = "0.2.31"
 description = "Shared data models and validation helpers for UnitySVC packages"
 readme = "README.md"
 authors = [{ name = "Bo Peng", email = "bo.peng@unitysvc.com" }]

{unitysvc_core-0.2.29 → unitysvc_core-0.2.31}/src/unitysvc_core/models/__init__.py

@@ -83,12 +83,14 @@ from .service_group_data import (
     validate_service_group,
 )
 from .validators import (
+    PLATFORM_SERVICES_DIRNAME,
     SUPPORTED_SERVICE_OPTIONS,
     suggest_valid_name,
     validate_listing_gateway_base_urls,
     validate_listing_s3_base_urls,
     validate_listing_smtp_base_urls,
     validate_name,
+    validate_platform_listing_base_urls,
     validate_s3_gateway_alias,
     validate_service_identifier,
     validate_service_options,
@@ -177,7 +179,9 @@ __all__ = [
     "validate_service_identifier",
     "validate_service_options",
     "validate_s3_gateway_alias",
+    "PLATFORM_SERVICES_DIRNAME",
     "validate_listing_gateway_base_urls",
+    "validate_platform_listing_base_urls",
     "validate_listing_s3_base_urls",
     "validate_listing_smtp_base_urls",
     "suggest_valid_name",

{unitysvc_core-0.2.29 → unitysvc_core-0.2.31}/src/unitysvc_core/models/pricing.py

@@ -12,13 +12,14 @@ Contains:
 from __future__ import annotations
 
 import ast
+import functools
 import operator
 import re
 from collections.abc import Callable, Iterable
 from decimal import Decimal, InvalidOperation
 from typing import Annotated, Any, Literal
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, TypeAdapter, model_validator
 from pydantic.functional_validators import BeforeValidator
 
 
@@ -1876,6 +1877,22 @@ Pricing = Annotated[
 ]
 
 
+@functools.cache
+def _pricing_adapter() -> TypeAdapter[Pricing]:
+    """The ``Pricing`` union's validator, built once and reused.
+
+    Building a ``TypeAdapter`` compiles the validation schema for every member
+    of the union, which costs ~0.4-0.5 ms; validating with it afterwards costs
+    microseconds. ``validate_pricing`` used to build one per call, and
+    composite prices (``multiply``, ``add``, ...) validate their nested parts
+    through it too, so pricing one usage event built it several times: ~2 ms
+    of CPU per event in the usage consumer (unitysvc/unitysvc#2591). Built
+    lazily rather than at import so ``Pricing``'s forward references are
+    resolved first. ``TypeAdapter`` is safe to share across threads.
+    """
+    return TypeAdapter(Pricing)
+
+
 def validate_pricing(
     data: dict[str, Any],
 ) -> (
@@ -1915,9 +1932,4 @@ def validate_pricing(
         >>> validated = validate_pricing(data)
         >>> print(validated.input)  # "0.5"
     """
-    from pydantic import TypeAdapter
-
-    adapter: TypeAdapter[TokenPriceData | TimePriceData | ImagePriceData | StepPriceData | RevenueSharePriceData] = (
-        TypeAdapter(Pricing)
-    )
-    return adapter.validate_python(data)
+    return _pricing_adapter().validate_python(data)

{unitysvc_core-0.2.29 → unitysvc_core-0.2.31}/src/unitysvc_core/models/validators.py

@@ -558,9 +558,16 @@ _API_GATEWAY_PREFIX = "${API_GATEWAY_BASE_URL}"
 _GATEWAY_SEGMENT_RE = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9._-]*$")
 
 
-def validate_listing_gateway_base_urls(user_access_interfaces: dict[str, Any] | None) -> list[str]:
+def validate_listing_gateway_base_urls(
+    user_access_interfaces: dict[str, Any] | None,
+    *,
+    platform_service: bool = False,
+) -> list[str]:
     """Validate ``${API_GATEWAY_BASE_URL}/...`` base_urls.
 
+    A **platform service**'s listing (``platform_service=True``) follows its own
+    rule instead: see :func:`validate_platform_listing_base_urls`.
+
     The gateway base_url is intentionally left almost unconstrained: a provider
     may route many services through a single base_url and differentiate them by
     other parts of the request (e.g. ``routing_key`` / ``model``), so we cannot
@@ -582,6 +589,8 @@ def validate_listing_gateway_base_urls(user_access_interfaces: dict[str, Any] |
 
     Returns a list of error messages (empty if all valid).
     """
+    if platform_service:
+        return validate_platform_listing_base_urls(user_access_interfaces)
     if not user_access_interfaces or not isinstance(user_access_interfaces, dict):
         return []
 
@@ -633,6 +642,68 @@ def validate_listing_gateway_base_urls(user_access_interfaces: dict[str, Any] |
     return errors
 
 
+# A platform service is published from ``platform-services/<provider>/<name>/``
+# (unitysvc#2569); its listing is the only one allowed a ``/p`` address.
+PLATFORM_SERVICES_DIRNAME = "platform-services"
+
+# Same grammar the platform enforces at publish time.
+_PLATFORM_BASE_URL_RE = re.compile(r"^\$\{API_GATEWAY_BASE_URL\}/p/(?P<route>[a-z0-9][a-z0-9_-]*)$")
+
+
+def validate_platform_listing_base_urls(user_access_interfaces: dict[str, Any] | None) -> list[str]:
+    """Validate a platform service listing's ``/p`` address.
+
+    A platform service is called at ``${API_GATEWAY_BASE_URL}/p/<route>``, which
+    ordinary listings may not use (single-letter prefixes are reserved). Its
+    listing must declare that address and nothing else:
+
+    - at least one interface;
+    - every ``base_url`` exactly ``${API_GATEWAY_BASE_URL}/p/<route>`` — lowercase
+      letters, digits, ``-`` and ``_``, starting with a letter or digit, no
+      further path;
+    - one ``<route>`` shared by all interfaces;
+    - the primary interface's ``routing_key``, if set, an object.
+
+    Mirrors the platform's publish-time check, so authors see these errors
+    before upload. Returns a list of error messages (empty if valid).
+    """
+    if (
+        not isinstance(user_access_interfaces, dict)
+        or not user_access_interfaces
+        or not all(isinstance(v, dict) for v in user_access_interfaces.values())
+    ):
+        return [
+            "user_access_interfaces: a platform service must declare its "
+            "'${API_GATEWAY_BASE_URL}/p/<route>' address (an object of interface objects keyed by name)"
+        ]
+
+    errors: list[str] = []
+    routes: set[str] = set()
+    for iface_name, iface in user_access_interfaces.items():
+        base_url = iface.get("base_url")
+        match = _PLATFORM_BASE_URL_RE.match(base_url) if isinstance(base_url, str) else None
+        if match is None:
+            errors.append(
+                f"user_access_interfaces.{iface_name}.base_url: a platform service's base_url must be "
+                f"exactly '${{API_GATEWAY_BASE_URL}}/p/<route>', got {base_url!r}"
+            )
+        else:
+            routes.add(match.group("route"))
+    if len(routes) > 1:
+        errors.append(
+            f"user_access_interfaces: all interfaces must share one /p route, got {', '.join(sorted(routes))}"
+        )
+
+    primary = sorted(
+        user_access_interfaces.items(),
+        key=lambda item: (not bool(item[1].get("is_primary")), int(item[1].get("sort_order") or 0), item[0]),
+    )[0]
+    routing_key = primary[1].get("routing_key")
+    if routing_key is not None and not isinstance(routing_key, dict):
+        errors.append(f"user_access_interfaces.{primary[0]}.routing_key: must be an object")
+    return errors
+
+
 def _earliest_dynamic_marker(s: str) -> int | None:
     """Return the index of the earliest dynamic-substitution marker in ``s``.
 

{unitysvc_core-0.2.29 → unitysvc_core-0.2.31}/src/unitysvc_core/validator.py

@@ -12,6 +12,12 @@ from jsonschema.validators import Draft7Validator
 
 from .utils import SCHEMA_TO_STEM, is_hidden_path, load_data_file, schema_for_path
 
+# ``details.model``: a provider-neutral model name (``glm-5.2``, not
+# ``zai-org/GLM-5.2`` or Fireworks' ``glm-5p2``). Lowercase, no ``org/``
+# prefix. The backend re-checks the same pattern before it shows a name on a
+# platform tier (``app/crud/platform_served.py``).
+CANONICAL_MODEL_RE = re.compile(r"^[a-z0-9][a-z0-9._:-]*$")
+
 # svcpass api_key dispositions (#1198, #1786). On an upstream_access_config
 # interface these literal values are not credentials: "" / "__strip__" strip
 # the svcpass-bearing header, "__forward__" forwards svcpass verbatim, and
@@ -665,6 +671,37 @@ class DataValidator:
 
         return errors
 
+    def validate_offering_model_name(self, data: dict[str, Any], schema_name: str) -> list[str]:
+        """Validate the optional ``details.model`` of an offering.
+
+        ``details.model`` names the model an offering serves in a
+        provider-neutral way, independent of the provider's own spelling
+        in ``details.upstream_model``. A platform tier lists its members'
+        names as the models it is currently served by (unitysvc#2567).
+
+        Only the shape is checked (lowercase, no ``org/`` prefix); there
+        is no registry of allowed names. Absent is fine.
+
+        Args:
+            data: The offering data being validated.
+            schema_name: The schema name (only ``offering_v1`` is checked).
+
+        Returns:
+            List of validation error messages.
+        """
+        if schema_name != "offering_v1":
+            return []
+        details = data.get("details")
+        if not isinstance(details, dict) or "model" not in details:
+            return []
+        value = details["model"]
+        if isinstance(value, str) and CANONICAL_MODEL_RE.match(value):
+            return []
+        return [
+            f"details.model must be a provider-neutral model name: lowercase letters, "
+            f"digits and '.', '_', ':', '-', with no 'org/' prefix (e.g. 'glm-5.2'), got {value!r}."
+        ]
+
     def validate_connectivity_test_exists(self, data: dict[str, Any], schema_name: str) -> list[str]:
         """Validate that at least one connectivity_test document exists.
 
@@ -921,6 +958,9 @@ class DataValidator:
         llm_metadata_errors = self.validate_llm_offering_metadata(data, schema_name)
         errors.extend(llm_metadata_errors)
 
+        # Validate the optional provider-neutral details.model (offering_v1 only)
+        errors.extend(self.validate_offering_model_name(data, schema_name))
+
         # Validate MCP offerings declare an mcp upstream channel (offering_v1
         # only); the customer-facing gateway interface is checked below with
         # the other listing_v1 interface rules.
@@ -940,6 +980,7 @@ class DataValidator:
         # Validate S3, SMTP, MCP, and API-gateway interfaces (listing_v1 only)
         if schema_name == "listing_v1":
             from .models.validators import (
+                PLATFORM_SERVICES_DIRNAME,
                 validate_access_interface_names,
                 validate_listing_gateway_base_urls,
                 validate_listing_jinja_var_references,
@@ -950,7 +991,15 @@ class DataValidator:
 
             uai = data.get("user_access_interfaces")
             errors.extend(validate_access_interface_names(uai))
-            errors.extend(validate_listing_gateway_base_urls(uai))
+            # A listing under platform-services/ is a platform service: its
+            # address is /p, which every other listing is refused.
+            try:
+                parts = file_path.resolve().relative_to(self.data_dir.resolve()).parts
+            except ValueError:
+                parts = file_path.parts
+            errors.extend(
+                validate_listing_gateway_base_urls(uai, platform_service=PLATFORM_SERVICES_DIRNAME in parts[:-1])
+            )
             errors.extend(validate_listing_s3_base_urls(uai))
             errors.extend(validate_listing_smtp_base_urls(uai))
             errors.extend(validate_listing_mcp_base_urls(uai))

{unitysvc_core-0.2.29 → unitysvc_core-0.2.31/src/unitysvc_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-core
-Version: 0.2.29
+Version: 0.2.31
 Summary: Shared data models and validation helpers for UnitySVC packages
 Author-email: Bo Peng <bo.peng@unitysvc.com>
 Maintainer-email: Bo Peng <bo.peng@unitysvc.com>

{unitysvc_core-0.2.29 → unitysvc_core-0.2.31}/tests/test_pricing.py

@@ -2156,3 +2156,53 @@ class TestChannelPriceData:
         assert pricing.calculate_cost(usage, request_count=10, channel="managed") == Decimal("5")
         assert pricing.calculate_cost(usage, request_count=10_000, channel="managed") == Decimal("50")
         assert pricing.calculate_cost(usage, request_count=10_000, channel="byok") == Decimal("0")
+
+
+class TestValidatePricingAdapterIsBuiltOnce:
+    """``validate_pricing`` reuses one ``TypeAdapter`` (unitysvc/unitysvc#2591).
+
+    Building the adapter compiles the whole ``Pricing`` union's schema
+    (~0.4-0.5 ms); the usage consumer validates several prices per event, so
+    rebuilding it per call made billing CPU-bound.
+    """
+
+    def test_repeated_calls_build_the_adapter_once(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        import unitysvc_core.models.pricing as pricing
+
+        built: list[object] = []
+        real = pricing.TypeAdapter
+
+        def counting(*args: object, **kwargs: object) -> object:
+            built.append(args)
+            return real(*args, **kwargs)
+
+        pricing._pricing_adapter.cache_clear()
+        monkeypatch.setattr(pricing, "TypeAdapter", counting)
+        try:
+            token = {"type": "one_million_tokens", "input": "0.5", "output": "1.5"}
+            composite = {
+                "type": "multiply",
+                "factor": "1.05",
+                "base": {"type": "one_million_tokens", "input": "0.5", "output": "1.5"},
+            }
+            for _ in range(50):
+                assert validate_pricing(token).input == "0.5"
+                validate_pricing(composite)
+        finally:
+            pricing._pricing_adapter.cache_clear()
+        assert len(built) == 1
+
+    def test_results_match_a_fresh_adapter(self) -> None:
+        from pydantic import TypeAdapter
+
+        from unitysvc_core.models.pricing import Pricing
+
+        for data in (
+            {"type": "one_million_tokens", "input": "0.5", "output": "1.5"},
+            {"type": "multiply", "factor": "2", "base": {"type": "constant", "price": "1"}},
+        ):
+            assert validate_pricing(data) == TypeAdapter(Pricing).validate_python(data)
+
+    def test_invalid_data_still_raises(self) -> None:
+        with pytest.raises(ValueError):
+            validate_pricing({"type": "no_such_price_type"})

{unitysvc_core-0.2.29 → unitysvc_core-0.2.31}/tests/test_validator.py

@@ -1164,6 +1164,35 @@ class TestAccessInterfaceNameValidation:
         assert "'ok_two'" not in joined
 
 
+class TestOfferingModelNameValidation:
+    """Tests for ``validate_offering_model_name``: ``details.model`` is an
+    optional, provider-neutral model name, checked for shape only."""
+
+    @pytest.mark.parametrize("name", ["glm-5.2", "kimi-k2.6", "deepseek-v4-pro", "qwen3:8b", "gpt_oss_120b"])
+    def test_canonical_names_pass(self, schema_dir, example_data_dir, name):
+        validator = DataValidator(example_data_dir, schema_dir)
+        data = {"service_type": "llm", "details": {"model": name}}
+        assert validator.validate_offering_model_name(data, "offering_v1") == []
+
+    def test_absent_passes(self, schema_dir, example_data_dir):
+        validator = DataValidator(example_data_dir, schema_dir)
+        assert validator.validate_offering_model_name({"details": {}}, "offering_v1") == []
+        assert validator.validate_offering_model_name({}, "offering_v1") == []
+
+    @pytest.mark.parametrize("name", ["zai-org/glm-5.2", "GLM-5.2", "", "-glm", "glm 5.2", None, 5])
+    def test_provider_spellings_rejected(self, schema_dir, example_data_dir, name):
+        validator = DataValidator(example_data_dir, schema_dir)
+        data = {"service_type": "llm", "details": {"model": name}}
+        errors = validator.validate_offering_model_name(data, "offering_v1")
+        assert len(errors) == 1
+        assert "details.model" in errors[0]
+
+    def test_other_schemas_ignored(self, schema_dir, example_data_dir):
+        validator = DataValidator(example_data_dir, schema_dir)
+        data = {"details": {"model": "Not/Canonical"}}
+        assert validator.validate_offering_model_name(data, "listing_v1") == []
+
+
 class TestLLMOfferingMetadataValidation:
     """Tests for ``validate_llm_offering_metadata``.
 
@@ -1637,3 +1666,42 @@ class TestSvcpassDisposition:
         data = {"service_options": {"ops_testing_parameters": {"api_key": "__sigv4__"}}}
         errors = validator.validate_api_key_secrets(data)
         assert errors and "secrets reference format" in errors[0]
+
+
+class TestPlatformServiceListingFile:
+    """``DataValidator`` applies the ``/p`` rule to listings under
+    ``platform-services/`` and the reserved-prefix rule everywhere else (#2569)."""
+
+    @staticmethod
+    def _write(path: Path, base_url: str) -> Path:
+        import json
+
+        path.parent.mkdir(parents=True)
+        path.write_text(
+            json.dumps(
+                {
+                    "name": "labs/demo",
+                    "user_access_interfaces": {"default": {"access_method": "http", "base_url": base_url}},
+                }
+            )
+        )
+        return path
+
+    @staticmethod
+    def _gateway_errors(validator: DataValidator, path: Path) -> list[str]:
+        _, errors = validator.validate_data_file(path, schema_name="listing_v1", check_name_consistency=False)
+        return [e for e in errors if "base_url" in e]
+
+    def test_platform_service_listing_may_use_p(self, schema_dir, tmp_path):
+        path = self._write(tmp_path / "platform-services/labs/demo/listing.json", "${API_GATEWAY_BASE_URL}/p/llm")
+        assert self._gateway_errors(DataValidator(tmp_path, schema_dir), path) == []
+
+    def test_platform_service_listing_must_use_p(self, schema_dir, tmp_path):
+        path = self._write(tmp_path / "platform-services/labs/demo/listing.json", "${API_GATEWAY_BASE_URL}/llm")
+        errors = self._gateway_errors(DataValidator(tmp_path, schema_dir), path)
+        assert len(errors) == 1 and "/p/<route>" in errors[0]
+
+    def test_ordinary_listing_may_not_use_p(self, schema_dir, tmp_path):
+        path = self._write(tmp_path / "specs/demo/listing.json", "${API_GATEWAY_BASE_URL}/p/llm")
+        errors = self._gateway_errors(DataValidator(tmp_path, schema_dir), path)
+        assert len(errors) == 1 and "reserved single-letter prefix" in errors[0]

{unitysvc_core-0.2.29 → unitysvc_core-0.2.31}/tests/test_validators.py

@@ -13,6 +13,7 @@ from unitysvc_core.models.validators import (
     validate_listing_mcp_base_urls,
     validate_mcp_namespace,
     validate_mcp_offering,
+    validate_platform_listing_base_urls,
     validate_service_identifier,
 )
 
@@ -623,3 +624,54 @@ class TestValidateMcpOffering:
         offering = self._offering()
         offering["user_access_interfaces"] = _mcp_uai()
         assert validate_mcp_offering(offering) == []
+
+
+class TestPlatformListingBaseUrls:
+    """A platform service's listing declares exactly its ``/p`` address (#2569)."""
+
+    @staticmethod
+    def _p(*base_urls: str, routing_key=None) -> dict:
+        uai = {f"i{n}": {"access_method": "http", "base_url": url} for n, url in enumerate(base_urls)}
+        if routing_key is not None:
+            uai["i0"]["routing_key"] = routing_key
+        return uai
+
+    def test_accepts_one_route(self) -> None:
+        uai = self._p("${API_GATEWAY_BASE_URL}/p/llm", "${API_GATEWAY_BASE_URL}/p/llm", routing_key={"model": "x"})
+        assert validate_platform_listing_base_urls(uai) == []
+        assert validate_listing_gateway_base_urls(uai, platform_service=True) == []
+
+    def test_ordinary_listing_still_refuses_p(self) -> None:
+        errors = validate_listing_gateway_base_urls(self._p("${API_GATEWAY_BASE_URL}/p/llm"))
+        assert any("reserved single-letter prefix" in e for e in errors)
+
+    @pytest.mark.parametrize(
+        "base_url",
+        [
+            "${API_GATEWAY_BASE_URL}/llm",
+            "${API_GATEWAY_BASE_URL}/p/llm/v1",
+            "${API_GATEWAY_BASE_URL}/p/LLM",
+            "${API_GATEWAY_BASE_URL}/p/{{ service_name }}",
+            "${API_GATEWAY_BASE_URL}/p/",
+            "https://example.com/p/llm",
+        ],
+    )
+    def test_rejects_anything_but_exactly_p_route(self, base_url: str) -> None:
+        errors = validate_platform_listing_base_urls(self._p(base_url))
+        assert len(errors) == 1
+        assert "user_access_interfaces.i0.base_url" in errors[0]
+
+    def test_rejects_mixed_routes(self) -> None:
+        errors = validate_platform_listing_base_urls(
+            self._p("${API_GATEWAY_BASE_URL}/p/llm", "${API_GATEWAY_BASE_URL}/p/embed")
+        )
+        assert errors == ["user_access_interfaces: all interfaces must share one /p route, got embed, llm"]
+
+    def test_rejects_non_object_routing_key(self) -> None:
+        errors = validate_platform_listing_base_urls(self._p("${API_GATEWAY_BASE_URL}/p/llm", routing_key="x"))
+        assert errors == ["user_access_interfaces.i0.routing_key: must be an object"]
+
+    @pytest.mark.parametrize("value", [None, {}, "not a dict", {"a": "not an object"}])
+    def test_requires_the_address(self, value) -> None:
+        errors = validate_platform_listing_base_urls(value)
+        assert len(errors) == 1 and "/p/<route>" in errors[0]