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

{unitysvc_core-0.2.31/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.31
+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.31 → unitysvc_core-0.2.32}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unitysvc-core"
-version = "0.2.31"
+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.31 → 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.31 → 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.31
+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.31 → 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
 # =============================================================================