unitysvc-core 0.2.28__tar.gz → 0.2.30__tar.gz

{unitysvc_core-0.2.28/src/unitysvc_core.egg-info → unitysvc_core-0.2.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-core
-Version: 0.2.28
+Version: 0.2.30
 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.28 → unitysvc_core-0.2.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unitysvc-core"
-version = "0.2.28"
+version = "0.2.30"
 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.28 → unitysvc_core-0.2.30}/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.28 → unitysvc_core-0.2.30}/src/unitysvc_core/models/pricing.py

@@ -342,6 +342,23 @@ def upstream_price_from_description(text: str | None) -> Decimal | None:
     return _blend(by_label["in"], by_label["out"]) * scale
 
 
+def _zero_rate(figure: EffectivePrice, description: str | None) -> EffectivePrice | None:
+    """A zero-rate price's effective price: free, or what the customer pays upstream.
+
+    A ``0`` with a description is a bring-your-own-key price: the customer pays
+    the upstream provider, at the rate the description states. A description
+    that states no parseable rate, or $0/$0 (what generators write when they
+    lack the provider's price), is unknown. A ``0`` with no description is
+    genuinely free.
+    """
+    if figure.amount != 0 or not description:
+        return figure
+    upstream = upstream_price_from_description(description)
+    if upstream is None or upstream == 0:
+        return None
+    return EffectivePrice(amount=upstream, unit=UNIT_TOKENS, source="upstream")
+
+
 # ============================================================================
 # Pricing Models - Discriminated Union for type-safe pricing validation
 # ============================================================================
@@ -475,14 +492,19 @@ class TokenPriceData(BasePriceData):
         return {"one_million_tokens": 1_000_000, "one_thousand_tokens": 1_000, "one_token": 1}[self.type]
 
     def effective_price(self) -> EffectivePrice | None:
-        """``(input + 4*output) / 5`` when priced separately, else ``price``; per 1M tokens."""
+        """``(input + 4*output) / 5`` when priced separately, else ``price``; per 1M tokens.
+
+        A zero rate with a description is a bring-your-own-key price: see
+        ``_zero_rate``.
+        """
         if self.input is not None and self.output is not None:
             per_unit = _blend(Decimal(self.input), Decimal(self.output))
         elif self.price is not None:
             per_unit = Decimal(self.price)
         else:
             return None
-        return _per_normalized_unit(self.type, per_unit)
+        figure = _per_normalized_unit(self.type, per_unit)
+        return None if figure is None else _zero_rate(figure, self.description)
 
     def calculate_cost(
         self,
@@ -931,19 +953,10 @@ class ConstantPriceData(BasePriceData):
     def effective_price(self) -> EffectivePrice | None:
         """``price`` per request.
 
-        A ``0`` with a description is a bring-your-own-key price: the customer
-        pays the upstream provider, at the rate the description states. A
-        description that states no parseable rate, or $0/$0 (what generators
-        write when they lack the provider's price), is unknown. A ``0`` with no
-        description is genuinely free.
+        A ``0`` with a description is a bring-your-own-key price: see
+        ``_zero_rate``.
         """
-        amount = Decimal(self.price)
-        if amount != 0 or not self.description:
-            return _rate(amount, UNIT_REQUEST)
-        upstream = upstream_price_from_description(self.description)
-        if upstream is None or upstream == 0:
-            return None
-        return EffectivePrice(amount=upstream, unit=UNIT_TOKENS, source="upstream")
+        return _zero_rate(_rate(Decimal(self.price), UNIT_REQUEST), self.description)
 
     def calculate_cost(
         self,
@@ -1904,7 +1917,5 @@ def validate_pricing(
     """
     from pydantic import TypeAdapter
 
-    adapter: TypeAdapter[TokenPriceData | TimePriceData | ImagePriceData | StepPriceData | RevenueSharePriceData] = (
-        TypeAdapter(Pricing)
-    )
+    adapter: TypeAdapter[Pricing] = TypeAdapter(Pricing)
     return adapter.validate_python(data)

{unitysvc_core-0.2.28 → unitysvc_core-0.2.30}/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.28 → unitysvc_core-0.2.30}/src/unitysvc_core/validator.py

@@ -940,6 +940,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 +951,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.28 → unitysvc_core-0.2.30/src/unitysvc_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-core
-Version: 0.2.28
+Version: 0.2.30
 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.28 → unitysvc_core-0.2.30}/tests/test_effective_price.py

@@ -112,6 +112,33 @@ class TestByokConstant:
         assert ep(priced) == rate("0.02", "request")
 
 
+class TestByokZeroRateTokens:
+    """Generators also write BYOK as a zero token rate, e.g. Mistral models."""
+
+    MISTRAL = (
+        "Free ~ BYOK | usage is billed by Mistral AI directly at $1.5 / $7.5 / $0.15 per 1M input/output/cached tokens"
+    )
+
+    def test_zero_split_rate_reads_description(self) -> None:
+        byok = {"type": "one_million_tokens", "input": "0", "output": "0", "cached_input": "0"}
+        figure = ep({**byok, "description": self.MISTRAL})
+        assert figure == rate("6.3", "one_million_tokens", "upstream")
+
+    def test_zero_unified_rate_reads_description(self) -> None:
+        figure = ep({"type": "one_thousand_tokens", "price": "0", "description": HF_UPSTREAM})
+        assert figure == rate("3.8", "one_million_tokens", "upstream")
+
+    def test_zero_rate_without_description_is_free(self) -> None:
+        assert ep({"type": "one_million_tokens", "input": "0", "output": "0"}) == rate("0", "one_million_tokens")
+
+    def test_zero_rate_with_unparseable_description_is_unknown(self) -> None:
+        assert ep({"type": "one_million_tokens", "price": "0", "description": "Bring your own key"}) is None
+
+    def test_nonzero_rate_ignores_description(self) -> None:
+        priced = {**TOKENS, "description": self.MISTRAL}
+        assert ep(priced) == rate("1.8", "one_million_tokens")
+
+
 class TestUpstreamPriceFromDescription:
     @pytest.mark.parametrize(
         ("text", "expected"),

{unitysvc_core-0.2.28 → unitysvc_core-0.2.30}/tests/test_validator.py

@@ -1637,3 +1637,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.28 → unitysvc_core-0.2.30}/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]