inline-core 1.2.72__tar.gz → 1.2.74__tar.gz

{inline_core-1.2.72 → inline_core-1.2.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: inline-core
-Version: 1.2.72
+Version: 1.2.74
 Summary: The generation engine behind Inline Studio.
 License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.11

{inline_core-1.2.72 → inline_core-1.2.74}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # PyPI name; the import package is `inline_core` (src/inline_core).
 name = "inline-core"
-version = "1.2.72"
+version = "1.2.74"
 description = "The generation engine behind Inline Studio."
 readme = "README.md"
 license = "GPL-3.0-or-later"

{inline_core-1.2.72 → inline_core-1.2.74}/src/inline_core/models/checkpoint.py

@@ -34,6 +34,38 @@ _DTYPE_NAMES = {
 }
 
 
+#: Markers a checkpoint carries when it was already quantized by someone else. ``comfy_quant`` is
+#: ComfyUI's own tag; ``weight_scale`` is the per-tensor scale every fp8/int8 repack ships beside
+#: the packed weights. Never match a bare ``.scale``: real models carry RMSNorm weights so named.
+_QUANT_MARKERS = ("comfy_quant", "weight_scale", "scale_weight", "weight_scale_2")
+_QUANT_DTYPES = frozenset({"I8", "U8"})
+
+
+def prequantized_kind(path: str | Path) -> str | None:
+    """What quantization a checkpoint already carries, or None if it is plain weights.
+
+    Loading one of these into a stock model silently drops the scales as unexpected keys, leaving
+    packed tensors in layers sized for unpacked ones - which surfaces as a shape mismatch deep in a
+    matmul rather than as a load error. Quantizing it a second time compounds that.
+    """
+    file = Path(path)
+    if not file.is_file() or file.suffix.lower() not in (".safetensors", ".sft"):
+        return None
+    try:
+        reader = CheckpointReader(file)
+        dtypes = reader.dtypes()
+    except Exception:  # noqa: BLE001 - unreadable is not classifiable
+        return None
+    if any(any(m in key for m in _QUANT_MARKERS) for key in dtypes):
+        return "prequantized"
+    weights = {d for key, d in dtypes.items() if key.endswith(".weight")}
+    if any(d.startswith("F8_") for d in weights):
+        return "fp8"
+    if weights & _QUANT_DTYPES:
+        return "int8"
+    return None
+
+
 class CheckpointReader:
     """Random access to one safetensors file, one tensor at a time."""
 

{inline_core-1.2.72 → inline_core-1.2.74}/src/inline_core/models/loaders.py

@@ -25,6 +25,7 @@ over it. Callers are the model-runner subpackages, which the server registers be
 from __future__ import annotations
 
 import hashlib
+import logging
 import os
 from collections.abc import Callable
 from dataclasses import dataclass
@@ -35,6 +36,9 @@ from typing import TYPE_CHECKING, Any
 from ..config import data_dir
 from ..device.policy import Quantization
 from ..errors import ComponentError
+from . import checkpoint
+
+logger = logging.getLogger("inline_core.loaders")
 
 if TYPE_CHECKING:
     from ..graph.loader_runners import LoraRef
@@ -663,14 +667,33 @@ def load_text_encoder(
         root = ensure_assets(arch)
         weights_dir = _staged_encoder_dir(arch, file)
         device_map = {"": device} if device else None
-        text_encoder = Qwen3Model.from_pretrained(
-            str(weights_dir),
-            torch_dtype=dtype,
-            low_cpu_mem_usage=True,
-            device_map=device_map,
-            local_files_only=True,
-            quantization_config=_quant_config(quant, framework="transformers"),
-        )
+        # A repack that already carries its own scales must not be quantized again, and transformers
+        # drops those scales as unexpected keys - leaving packed tensors in layers sized for
+        # unpacked ones, which surfaces as a matmul shape error rather than a load failure.
+        carried = checkpoint.prequantized_kind(file)
+        effective = Quantization.NONE if carried else quant
+        if carried:
+            logger.info(
+                "%s is a %s text encoder; loading it as-is rather than quantizing on top.",
+                Path(file).name, carried,
+            )
+        try:
+            text_encoder = Qwen3Model.from_pretrained(
+                str(weights_dir),
+                torch_dtype=dtype,
+                low_cpu_mem_usage=True,
+                device_map=device_map,
+                local_files_only=True,
+                quantization_config=_quant_config(effective, framework="transformers"),
+            )
+        except Exception as error:
+            if not carried:
+                raise
+            raise ComponentError(
+                f"{Path(file).name} is a {carried} text encoder, which this loader cannot read: "
+                "its scales are not part of the stock Qwen3 layout. Use the full-precision encoder "
+                "(qwen_3_8b.safetensors from Comfy-Org/flux2-klein-9B)."
+            ) from error
         tokenizer = AutoTokenizer.from_pretrained(str(root / "tokenizer"), local_files_only=True)
         return text_encoder, tokenizer
 

{inline_core-1.2.72 → inline_core-1.2.74}/src/inline_core/server/app.py

@@ -6,6 +6,7 @@ import asyncio
 import hashlib
 import json
 import logging
+import mimetypes
 import os
 import re
 import tempfile
@@ -112,6 +113,27 @@ def _version(registry: Registry, catalog: ModelCatalog) -> str:
     return f"r_{hashlib.sha256(payload.encode()).hexdigest()[:8]}"
 
 
+# The SPA's content types, pinned rather than asked of the host - see _pin_web_mime_types.
+_WEB_MIME_TYPES = (
+    (".js", "text/javascript"),
+    (".mjs", "text/javascript"),
+    (".css", "text/css"),
+    (".json", "application/json"),
+    (".map", "application/json"),
+    (".svg", "image/svg+xml"),
+    (".wasm", "application/wasm"),
+    (".woff2", "font/woff2"),
+)
+
+
+def _pin_web_mime_types() -> None:
+    """A clean Windows install sets HKCR\\.js = text/plain and Python lets that registry value
+    override its own table, so the SPA's ES modules ship as text/plain and no browser executes
+    them - a blank page. add_type runs after the registry read, so these win."""
+    for ext, mime in _WEB_MIME_TYPES:
+        mimetypes.add_type(mime, ext)
+
+
 def create_app(
     registry: Registry | None = None,
     cache: NodeCache | None = None,
@@ -128,6 +150,7 @@ def create_app(
 ) -> FastAPI:
     _setup_app_logging()
     _quiet_access_log()
+    _pin_web_mime_types()
     registry = registry or build_default_registry()
     cache = cache or InMemoryCache()
     policy = policy or MemoryPolicy()

{inline_core-1.2.72 → inline_core-1.2.74}/tests/test_checkpoint.py

@@ -8,9 +8,14 @@ must agree with safetensors exactly.
 
 from __future__ import annotations
 
+import json
+import struct
+from pathlib import Path
+
 import pytest
 
 from inline_core.errors import ComponentError
+from inline_core.models import checkpoint
 from inline_core.models.checkpoint import CheckpointReader
 
 torch = pytest.importorskip("torch")
@@ -77,3 +82,62 @@ def test_a_non_checkpoint_file_is_a_clear_error(tmp_path) -> None:
 def test_a_missing_file_is_a_clear_error(tmp_path) -> None:
     with pytest.raises(ComponentError, match="Could not read checkpoint"):
         CheckpointReader(tmp_path / "absent.safetensors")
+
+
+# --- already-quantized checkpoints ---------------------------------------------------------------
+#
+# A ComfyUI-quantized text encoder loads into a stock Qwen3Model with its `comfy_quant` and
+# `weight_scale` keys dropped as unexpected, leaving packed tensors in layers sized for unpacked
+# ones. That surfaced as a matmul shape error deep inside torchao, after the pipeline had
+# already reported itself ready.
+
+
+def _write(path: Path, index: dict[str, object]) -> Path:
+    blob = json.dumps(index).encode()
+    path.write_bytes(struct.pack("<Q", len(blob)) + blob + b"\x00" * 64)
+    return path
+
+
+def _t(dtype: str, shape: list[int]) -> dict[str, object]:
+    return {"dtype": dtype, "shape": shape, "data_offsets": [0, 1]}
+
+
+def test_a_comfy_quantized_encoder_is_recognised(tmp_path: Path) -> None:
+    file = _write(
+        tmp_path / "qwen_3_8b_comfyquant.safetensors",
+        {
+            "model.layers.0.self_attn.k_proj.weight": _t("I8", [1024, 2048]),
+            "model.layers.0.self_attn.k_proj.weight_scale": _t("F32", [1024]),
+            "model.layers.0.self_attn.k_proj.comfy_quant": _t("I8", []),
+        },
+    )
+    assert checkpoint.prequantized_kind(file) == "prequantized"
+
+
+def test_an_fp8_checkpoint_is_recognised(tmp_path: Path) -> None:
+    file = _write(
+        tmp_path / "enc_fp8.safetensors",
+        {"model.layers.0.mlp.up_proj.weight": _t("F8_E4M3", [4096, 4096])},
+    )
+    assert checkpoint.prequantized_kind(file) == "fp8"
+
+
+def test_a_plain_checkpoint_is_not_flagged(tmp_path: Path) -> None:
+    """A false positive here refuses to quantize a model that needs it, so it must not fire on
+    ordinary weights or on the RMSNorm tensors every transformer carries."""
+    file = _write(
+        tmp_path / "qwen_3_8b.safetensors",
+        {
+            "model.layers.0.self_attn.k_proj.weight": _t("BF16", [1024, 4096]),
+            "model.layers.0.input_layernorm.weight": _t("BF16", [4096]),
+            "model.layers.0.self_attn.q_norm.scale": _t("BF16", [128]),
+        },
+    )
+    assert checkpoint.prequantized_kind(file) is None
+
+
+def test_an_unreadable_file_is_not_classified(tmp_path: Path) -> None:
+    junk = tmp_path / "junk.safetensors"
+    junk.write_bytes(b"\x00" * 32)
+    assert checkpoint.prequantized_kind(junk) is None
+    assert checkpoint.prequantized_kind(tmp_path / "missing.safetensors") is None

{inline_core-1.2.72 → inline_core-1.2.74}/tests/test_frontend_serving.py

@@ -4,13 +4,15 @@ the /v1 API still winning. No torch/models needed."""
 from __future__ import annotations
 
 import builtins
+import mimetypes
 import sys
 import types
 from pathlib import Path
 
+import pytest
 from fastapi.testclient import TestClient
 
-from inline_core.server.app import create_app
+from inline_core.server.app import _WEB_MIME_TYPES, create_app
 from inline_core.server.frontend import resolve_frontend_root
 
 
@@ -109,3 +111,29 @@ def test_no_mount_when_frontend_root_is_none(tmp_path):
     with TestClient(app) as client:
         assert client.get("/v1/health").status_code == 200
         assert client.get("/").status_code == 404  # API only, no SPA
+
+
+@pytest.fixture
+def hostile_host_mime_table():
+    mimetypes.init()  # rebind the module globals the way first use does, then poison them
+    for ext, _ in _WEB_MIME_TYPES:
+        mimetypes.add_type("text/plain", ext)
+    try:
+        yield
+    finally:
+        mimetypes.init()
+
+
+def test_serves_js_as_javascript_when_the_host_table_is_wrong(tmp_path, hostile_host_mime_table):
+    root = _spa(tmp_path)
+    app = create_app(frontend_root=str(root))
+    with TestClient(app) as client:
+        asset = client.get("/assets/index-abc123.js")
+    # text/plain here blocks the ES module outright and the app renders a blank page.
+    assert asset.headers["content-type"].split(";")[0] == "text/javascript"
+
+
+def test_create_app_pins_every_web_mime_type(tmp_path, hostile_host_mime_table):
+    create_app(frontend_root=str(_spa(tmp_path)))
+    for ext, mime in _WEB_MIME_TYPES:
+        assert mimetypes.guess_type(f"asset{ext}")[0] == mime

{inline_core-1.2.72 → inline_core-1.2.74}/uv.lock

@@ -610,7 +610,7 @@ wheels = [
 
 [[package]]
 name = "inline-core"
-version = "1.2.70"
+version = "1.2.74"
 source = { editable = "." }
 dependencies = [
     { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },