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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unitysvc-core"
-version = "0.2.30"
+version = "0.2.32"
 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.30 → unitysvc_core-0.2.32}/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,7 +1932,4 @@ def validate_pricing(
         >>> validated = validate_pricing(data)
         >>> print(validated.input)  # "0.5"
     """
-    from pydantic import TypeAdapter
-
-    adapter: TypeAdapter[Pricing] = TypeAdapter(Pricing)
-    return adapter.validate_python(data)
+    return _pricing_adapter().validate_python(data)

{unitysvc_core-0.2.30 → unitysvc_core-0.2.32}/src/unitysvc_core/utils.py

@@ -11,6 +11,7 @@ and unitysvc backend, including:
 
 import hashlib
 import json
+import mimetypes
 import os
 import tomllib
 import warnings
@@ -104,52 +105,71 @@ def get_basename(filename: str) -> str:
 
 
 def mime_type_to_extension(mime_type: str) -> str:
-    """Convert MIME type to file extension.
+    """File extension for a media type or a document-kind token.
+
+    Both forms arrive here. ``Document.mime_type`` is a :class:`MimeTypeEnum`,
+    whose values are document KINDS rather than media types -- ``png``,
+    ``markdown``, ``python``, and ``url``, which is not a media type at all --
+    while other callers pass a real ``image/png``. A kind that fell through to
+    ``txt`` meant a PNG stored under a ``.txt`` key and served as
+    ``text/plain``, which browsers refuse to render under ``nosniff``.
+
+    Resolution order: the explicit table, then the stdlib (which knows every
+    image kind both as a media type and as an extension), then the media type's
+    subtype, then ``txt``. The fallback stays: an honest, uninformative
+    extension beats a guessed-wrong media type.
 
     Args:
-        mime_type: MIME type string
+        mime_type: A media type (``image/png``) or a kind token (``png``).
 
     Returns:
-        File extension without dot
+        File extension without the dot.
     """
-    # Common MIME type to extension mappings
-    mime_map = {
+    if not mime_type:
+        return "txt"
+
+    value = mime_type.strip().lower()
+    if not value:
+        return "txt"
+
+    # Spelled out where the stdlib is absent or disagrees with what we store:
+    # the languages have no media type it knows, ``url`` is not a media type,
+    # and we store ``.md`` and ``.jpg`` rather than ``.markdown`` and ``.jpeg``.
+    explicit = {
         "text": "txt",
         "plain": "txt",
         "text/plain": "txt",
-        "text/html": "html",
         "text/markdown": "md",
-        "text/csv": "csv",
-        "application/json": "json",
-        "application/pdf": "pdf",
-        "application/xml": "xml",
-        "application/x-yaml": "yaml",
-        "application/octet-stream": "bin",
-        "image/png": "png",
-        "image/jpeg": "jpg",
-        "image/gif": "gif",
         "markdown": "md",
-        "html": "html",
-        "json": "json",
-        "pdf": "pdf",
-        "xml": "xml",
+        "image/jpeg": "jpg",
+        "jpeg": "jpg",
+        "python": "py",
+        "javascript": "js",
+        "bash": "sh",
         "yaml": "yaml",
-        "csv": "csv",
+        "application/x-yaml": "yaml",
+        "application/octet-stream": "bin",
         "url": "url",
     }
+    if value in explicit:
+        return explicit[value]
+
+    if "/" in value:
+        guessed = mimetypes.guess_extension(value)
+        if guessed:
+            return guessed.lstrip(".")
+        subtype = value.split("/", 1)[1]
+        if subtype in explicit:
+            return explicit[subtype]
+        if mimetypes.guess_type(f"x.{subtype}")[0]:
+            return subtype
+        return "txt"
+
+    # A bare token that is already a real extension: png, svg, webp, pdf, json,
+    # html, csv, xml. Resolved rather than listed, so the table stays short.
+    if mimetypes.guess_type(f"x.{value}")[0]:
+        return value
 
-    # Try exact match first
-    mime_lower = mime_type.lower()
-    if mime_lower in mime_map:
-        return mime_map[mime_lower]
-
-    # Try to extract from mime type parts
-    if "/" in mime_lower:
-        _, subtype = mime_lower.split("/", 1)
-        if subtype in mime_map:
-            return mime_map[subtype]
-
-    # Default to txt
     return "txt"
 
 

{unitysvc_core-0.2.30 → unitysvc_core-0.2.32}/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.

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

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

@@ -5,6 +5,7 @@ from pathlib import Path
 
 import pytest
 
+from unitysvc_core.models.base import MimeTypeEnum
 from unitysvc_core.utils import (
     DEFAULT_PRESET_FNS,
     DataFileLoadWarning,
@@ -64,6 +65,70 @@ def test_mime_type_to_extension() -> None:
     assert mime_type_to_extension("application/pdf") == "pdf"
 
 
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [
+        ("image/png", "png"),
+        ("image/jpeg", "jpg"),
+        ("image/svg+xml", "svg"),
+        ("image/webp", "webp"),
+        ("text/markdown", "md"),
+        ("text/plain", "txt"),
+        ("application/json", "json"),
+    ],
+)
+def test_a_media_type_resolves_to_its_extension(value: str, expected: str) -> None:
+    assert mime_type_to_extension(value) == expected
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [
+        ("markdown", "md"),
+        ("python", "py"),
+        ("javascript", "js"),
+        ("bash", "sh"),
+        ("html", "html"),
+        ("json", "json"),
+        ("text", "txt"),
+        ("pdf", "pdf"),
+        ("jpeg", "jpg"),
+        ("png", "png"),
+        ("svg", "svg"),
+        ("webp", "webp"),
+        ("url", "url"),
+    ],
+)
+def test_a_document_kind_token_resolves_to_its_extension(
+    value: str, expected: str
+) -> None:
+    """``Document.mime_type`` is a ``MimeTypeEnum``, whose values are kinds
+    rather than media types. A kind that fell through to ``txt`` meant a PNG
+    stored under a ``.txt`` key and served as ``text/plain``."""
+    assert mime_type_to_extension(value) == expected
+
+
+def test_every_mime_type_enum_value_resolves() -> None:
+    """The regression this guards: an unknown kind became ``txt`` silently."""
+    unresolved = [
+        kind.value
+        for kind in MimeTypeEnum
+        if kind is not MimeTypeEnum.text and mime_type_to_extension(kind.value) == "txt"
+    ]
+
+    assert unresolved == []
+
+
+@pytest.mark.parametrize("value", ["", "   ", "not-a-thing", "application/x-unknown"])
+def test_an_unresolvable_value_falls_back_to_txt(value: str) -> None:
+    assert mime_type_to_extension(value) == "txt"
+
+
+def test_case_and_whitespace_are_not_the_callers_problem() -> None:
+    assert mime_type_to_extension("PNG") == "png"
+    assert mime_type_to_extension("  image/png  ") == "png"
+
+
 # =============================================================================
 # deep_merge_dicts
 # =============================================================================

{unitysvc_core-0.2.30 → unitysvc_core-0.2.32}/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``.