inline-core 1.2.64__tar.gz → 1.2.65__tar.gz

{inline_core-1.2.64 → inline_core-1.2.65}/PKG-INFO

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

{inline_core-1.2.64 → inline_core-1.2.65}/pyproject.toml

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

{inline_core-1.2.64 → inline_core-1.2.65}/src/inline_core/device/detect.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterable
+from string import ascii_letters
+
 from .types import Device, DeviceKind
 
 
@@ -80,6 +83,37 @@ def cpu_only_torch_warning() -> str | None:
     )
 
 
+def _parse_arch(arch: str) -> tuple[int, int] | None:
+    """``sm_120`` to ``(12, 0)``.
+
+    The minor is the **last digit** and the major is everything before it, so ``sm_100`` is (10, 0).
+    Reading left to right instead gives (1, 20) and puts the bug precisely on the Blackwell parts.
+    Tuned variants (``sm_90a``) drop their trailing letters.
+    """
+    digits = arch[3:].rstrip(ascii_letters)
+    if len(digits) < 2 or not digits.isdigit():
+        return None
+    return int(digits[:-1]), int(digits[-1])
+
+
+def arch_list_covers(arches: Iterable[str], major: int, minor: int) -> bool:
+    """Whether a wheel's arch list has kernels that will run on a ``(major, minor)`` device.
+
+    CUDA binary compatibility runs **upward within one major only**: an ``sm_8x`` cubin executes on
+    any ``sm_8y`` where ``y >= x``. So ``sm_86`` covers an sm_89 Ada card, which is why exact
+    matching told every RTX 40-series owner their install was broken. Crossing a major never works,
+    so ``sm_90`` does not cover sm_120 and the Blackwell warning stays correct.
+
+    PTX entries (``compute_90``) JIT forward but are not matched here: they do not start with
+    ``sm_``, so a PTX-carrying wheel still warns. Rare, and warning is the safe way to be wrong.
+    """
+    for arch in arches:
+        parsed = _parse_arch(arch)
+        if parsed is not None and parsed[0] == major and parsed[1] <= minor:
+            return True
+    return False
+
+
 def unsupported_arch_warning() -> str | None:
     """A warning when the installed torch has no kernels for the GPU it is about to run on.
 
@@ -105,16 +139,15 @@ def unsupported_arch_warning() -> str | None:
             return None  # a CPU-only build; cpu_only_torch_warning owns that case
         major, minor = get_capability(0)
         target = f"sm_{major}{minor}"
-        # startswith, because a wheel lists tuned variants like sm_90a for the same architecture.
-        if any(arch.startswith(target) for arch in arches):
+        if arch_list_covers(arches, major, minor):
             return None
         name = _device_name(torch) or "The detected NVIDIA GPU"
         return (
             f"{name} is compute capability {target}, but this install's PyTorch only has kernels "
             f"for {' '.join(arches)}. Generation will fail or fall back to the CPU. Re-run "
             "`webui.sh --install` (Windows: `.\\webui.bat --install`) to pick the wheel index that "
-            "matches the card, or force one with `--torch-index cu130` - `cu128` if the driver "
-            "predates CUDA 13."
+            "matches the card, or force one with `--torch-index cu130`. On a Blackwell card whose "
+            "driver predates R580, use `cu128`, which still has sm_120 but is frozen at torch 2.11."
         )
     except Exception:  # noqa: BLE001 - a diagnostic must never break startup
         return None

inline_core-1.2.65/src/inline_core/device/probe.py

@@ -0,0 +1,76 @@
+"""Install-time probe: which torch is installed, and does it have kernels for this card?
+
+Run as ``python -m inline_core.device.probe`` by both launchers. They cannot share the
+compatibility rule any other way, and restating it in bash and batch is how the two drift.
+
+Always prints one JSON object and always exits 0, so a shell branches on ``status`` rather than
+parsing stderr. A **nonzero exit means the probe itself failed**, which callers must treat as
+unknown and never as covered.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from typing import Any
+
+from .detect import arch_list_covers
+
+#: A local version tag we recognise as a pytorch.org build, e.g. ``2.13.0+cu130`` or ``2.9.0+cpu``.
+#: Only these are safe to replace automatically: a ROCm build, a nightly or a hand-built wheel will
+#: also fail the arch check, and silently reinstalling over someone's deliberate choice is worse
+#: than the wrong wheel.
+_REPLACEABLE_LOCAL = re.compile(r"\+(?:cpu|cu\d+)$")
+
+
+def probe() -> dict[str, Any]:
+    """What the launcher needs to decide whether to replace torch. Never raises."""
+    out: dict[str, Any] = {
+        "status": "unknown",
+        "torch": None,
+        "cuda": None,
+        "archList": [],
+        "capability": None,
+        "replaceable": False,
+    }
+    try:
+        import torch
+    except Exception:  # noqa: BLE001 - no torch yet is a normal first install
+        out["status"] = "no-torch"
+        return out
+
+    try:
+        out["torch"] = str(torch.__version__)
+        out["cuda"] = getattr(torch.version, "cuda", None)
+        out["replaceable"] = bool(_REPLACEABLE_LOCAL.search(out["torch"]))
+        # HIP reports gfx arches through the sm_ call, so the rule does not apply. Never
+        # auto-replace a ROCm build.
+        if getattr(torch.version, "hip", None):
+            out["status"] = "rocm"
+            out["replaceable"] = False
+            return out
+        arches = [str(a) for a in torch.cuda.get_arch_list() if str(a).startswith("sm_")]
+        out["archList"] = arches
+        if not arches:
+            out["status"] = "cpu-only"
+            return out
+        if torch.cuda.device_count() < 1:
+            out["status"] = "no-gpu"
+            return out
+        major, minor = torch.cuda.get_device_capability(0)
+        out["capability"] = [major, minor]
+        out["status"] = "covered" if arch_list_covers(arches, major, minor) else "uncovered"
+    except Exception:  # noqa: BLE001 - a broken torch is exactly what we are here to detect
+        out["status"] = "unknown"
+    return out
+
+
+def main() -> int:
+    json.dump(probe(), sys.stdout)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{inline_core-1.2.64 → inline_core-1.2.65}/src/inline_core/models/minimaxh3/load.py

@@ -157,6 +157,14 @@ def load_transformer(
 
     if lora_plan:
         _finish_fuse(model, lora_plan, fused)
+        # Announced because a fused LoRA is otherwise invisible: it changes the weights and nothing
+        # else, so a run with no adapter and a run with one that never arrived look identical in
+        # the log, and the only way to tell them apart was to render twice and compare.
+        logger.info(
+            "MiniMax H3: fused %d LoRA layer(s) from %s",
+            len(lora_plan),
+            ", ".join(f"{Path(ref.file).name}@{ref.strength:g}" for ref in loras),
+        )
     _assert_nothing_left_on_meta(model, filled)
     model.eval()
     return model

{inline_core-1.2.64 → inline_core-1.2.65}/src/inline_core/training/cache.py

@@ -30,6 +30,7 @@ def build(
     flip: bool = False,
     dropout: float = 0.0,
     clip_frames: int = 1,
+    clip_window: str = "start",
     on_status: Callable[[str], None] | None = None,
 ) -> tuple[list[dict[str, Any]], dict[str, Any] | None, float]:
     """Return ``(items, unconditional, shift)``, all as CPU tensors, with the encoders freed.
@@ -43,7 +44,7 @@ def build(
 
         items, unconditional = h3.precache(
             dataset_dir, models_dir, device, dtype, resolution, flip, dropout > 0, clip_frames,
-            on_status=on_status,
+            clip_window=clip_window, on_status=on_status,
         )
         return items, unconditional, _H3_SHIFT
 

{inline_core-1.2.64 → inline_core-1.2.65}/src/inline_core/training/h3.py

@@ -44,6 +44,7 @@ def precache(
     flip: bool,
     want_unconditional: bool,
     clip_frames: int = 1,
+    clip_window: str = "start",
     on_status: Callable[[str], None] | None = None,
 ) -> tuple[list[dict[str, Any]], dict[str, Any] | None]:
     """Every image as a latent and every caption as conditioning, as CPU tensors."""
@@ -57,7 +58,9 @@ def precache(
     root = Path(models_dir)
     # Only the clips that survived encoding carry captions, or every caption after the first skip
     # would be paired with the wrong latent.
-    latents, kept = _encode_pixels(root, pairs, device, resolution, flip, clip_frames, say)
+    latents, kept = _encode_pixels(
+        root, pairs, device, resolution, flip, clip_frames, say, clip_window
+    )
     if not kept:
         raise RuntimeError(
             f"None of the {len(pairs)} dataset items could be encoded. For clips, each must be at "
@@ -89,6 +92,7 @@ def precache(
 def _encode_pixels(
     root: Path, pairs: list[tuple[Path, str]], device: str, resolution: int, flip: bool,
     clip_frames: int = 1, say: Callable[[str], None] = lambda _text: None,
+    clip_window: str = "start",
 ) -> tuple[list[Any], list[tuple[Path, str]]]:
     """Pass one: the video VAE, then dropped. Returns the latents and the pairs they came from."""
     import numpy
@@ -114,7 +118,9 @@ def _encode_pixels(
         for index, (path, _caption) in enumerate(pairs, start=1):
             clip = ds.is_video(path)
             try:
-                frames = _clip_frames(path, clip_frames) if clip else [Image.open(path)]
+                frames = (
+                    _clip_frames(path, clip_frames, clip_window) if clip else [Image.open(path)]
+                )
             except ShortClipError as exc:
                 skipped.append(path.name)
                 say(f"skipped {exc}")
@@ -151,11 +157,14 @@ class ShortClipError(RuntimeError):
     not throw away a precache that takes many minutes."""
 
 
-def _clip_frames(path: Path, clip_frames: int) -> list[Any]:
-    """A clip as PIL frames on H3's 24fps, 17n+5 grid, taken from the start.
+def _clip_frames(path: Path, clip_frames: int, window: str = "start") -> list[Any]:
+    """A clip as PIL frames on H3's 24fps, 17n+5 grid.
 
     Trimmed rather than sampled: a fixed window keeps the precache to one encode per clip, and
     re-encoding a different window every step would defeat caching the latents at all.
+
+    The grid only snaps **down**, so some of every clip is always dropped. ``window="end"`` takes
+    the tail instead of the head, for footage whose action is at the finish.
     """
     from PIL import Image
 
@@ -173,7 +182,8 @@ def _clip_frames(path: Path, clip_frames: int) -> list[Any]:
             f"{path.name} is {frames.shape[0]} frames once resampled to {_H3_FPS}fps, below H3's "
             f"{keep}-frame minimum ({keep / _H3_FPS:.2f}s). Skipped."
         )
-    return [Image.fromarray(frame) for frame in frames[:keep]]
+    kept = frames[-keep:] if window == "end" else frames[:keep]
+    return [Image.fromarray(frame) for frame in kept]
 
 
 def _encode_captions(

{inline_core-1.2.64 → inline_core-1.2.65}/src/inline_core/training/trainer.py

@@ -184,6 +184,7 @@ def train(manifest: dict[str, Any]) -> str | None:
         manifest["datasetDir"], manifest["modelsDir"], arch.key, str(device), dtype, resolution,
         flip=bool(hp.get("flipAugment")), dropout=dropout,
         clip_frames=archs.clip_frames(arch, hp.get("clipSeconds")),
+        clip_window=str(hp.get("clipWindow") or "start"),
         on_status=lambda text: protocol.progress(0, steps, status=text),
     )
 

{inline_core-1.2.64 → inline_core-1.2.65}/tests/test_device_detect.py

@@ -192,3 +192,132 @@ def test_silent_without_torch(monkeypatch) -> None:
     monkeypatch.setattr(builtins, "__import__", _no_torch)
     monkeypatch.delitem(__import__("sys").modules, "torch", raising=False)
     assert detect.cpu_only_torch_warning() is None
+
+
+# --- CUDA within-major binary compatibility -----------------------------------------------------
+#
+# A cubin built for sm_8x runs on any sm_8y where y >= x, so sm_86 covers an sm_89 Ada card. Exact
+# per-minor matching told every RTX 40-series owner their install was broken.
+
+_CU130_ARCHES = ["sm_75", "sm_80", "sm_86", "sm_90", "sm_100", "sm_120"]
+
+
+def test_arch_parse_reads_the_minor_as_the_last_digit() -> None:
+    """sm_120 is (12, 0), not (1, 20). Left-to-right puts the bug on the Blackwell parts."""
+    assert detect._parse_arch("sm_120") == (12, 0)
+    assert detect._parse_arch("sm_100") == (10, 0)
+    assert detect._parse_arch("sm_90a") == (9, 0)  # tuned variant
+    assert detect._parse_arch("compute_90") is None
+
+
+def test_ada_is_covered_by_ampere_kernels(monkeypatch) -> None:
+    """The RTX 4080 false positive: sm_89 against a wheel whose newest 8.x is sm_86."""
+    monkeypatch.setitem(
+        __import__("sys").modules,
+        "torch",
+        _fake_arch_torch(capability=(8, 9), arches=_CU124_ARCHES),
+    )
+    assert detect.unsupported_arch_warning() is None
+
+
+def test_compatibility_runs_upward_only(monkeypatch) -> None:
+    """An sm_86 cubin does NOT run on an sm_80 A100, so that must still warn."""
+    monkeypatch.setitem(
+        __import__("sys").modules,
+        "torch",
+        _fake_arch_torch(capability=(8, 0), arches=["sm_86"]),
+    )
+    assert detect.unsupported_arch_warning() is not None
+
+
+def test_a_dropped_architecture_still_warns(monkeypatch) -> None:
+    """cu130 dropped Volta; sm_70 has no same-major kernel at or below it."""
+    monkeypatch.setitem(
+        __import__("sys").modules,
+        "torch",
+        _fake_arch_torch(capability=(7, 0), arches=_CU130_ARCHES),
+    )
+    assert detect.unsupported_arch_warning() is not None
+
+
+def test_blackwell_majors_do_not_cover_each_other() -> None:
+    """sm_100 and sm_120 are both Blackwell but different majors, so neither covers the other."""
+    assert detect.arch_list_covers(["sm_100"], 12, 0) is False
+    assert detect.arch_list_covers(["sm_120"], 10, 0) is False
+    assert detect.arch_list_covers(_CU130_ARCHES, 10, 0) is True
+    assert detect.arch_list_covers(_CU130_ARCHES, 12, 0) is True
+
+
+# --- the install-time probe --------------------------------------------------------------------
+
+
+def _fake_probe_torch(
+    *, version: str, arches: list[str], capability: tuple[int, int] | None = (12, 0),
+    hip: str | None = None, devices: int = 1,
+) -> types.SimpleNamespace:
+    return types.SimpleNamespace(
+        __version__=version,
+        version=types.SimpleNamespace(cuda=None if "+cpu" in version else "12.8", hip=hip),
+        cuda=types.SimpleNamespace(
+            device_count=lambda: devices,
+            get_arch_list=lambda: arches,
+            get_device_capability=lambda i=0: capability,
+        ),
+    )
+
+
+def _probe_with(monkeypatch, torch_stub) -> dict:
+    from inline_core.device import probe as probe_mod
+
+    monkeypatch.setitem(__import__("sys").modules, "torch", torch_stub)
+    return probe_mod.probe()
+
+
+def test_probe_reports_an_uncovered_wheel_as_replaceable(monkeypatch) -> None:
+    """The 5060 Ti case: a cu126 wheel on sm_120, and the +cuXXX tag makes it safe to replace."""
+    got = _probe_with(
+        monkeypatch, _fake_probe_torch(version="2.9.0+cu126", arches=_CU124_ARCHES)
+    )
+    assert got["status"] == "uncovered"
+    assert got["replaceable"] is True
+
+
+def test_probe_reports_ada_as_covered(monkeypatch) -> None:
+    got = _probe_with(
+        monkeypatch,
+        _fake_probe_torch(version="2.13.0+cu130", arches=_CU130_ARCHES, capability=(8, 9)),
+    )
+    assert got["status"] == "covered"
+
+
+def test_probe_never_offers_to_replace_a_rocm_build(monkeypatch) -> None:
+    """The safety gate. A ROCm build fails the sm_ rule too, and reinstalling over someone's
+    deliberate choice is worse than the wrong wheel."""
+    got = _probe_with(
+        monkeypatch,
+        _fake_probe_torch(version="2.9.0+rocm6.2", arches=[], hip="6.2.0"),
+    )
+    assert got["status"] == "rocm"
+    assert got["replaceable"] is False
+
+
+def test_probe_never_offers_to_replace_an_untagged_build(monkeypatch) -> None:
+    """A nightly or hand-built wheel carries no +cpu/+cuXXX tag, so leave it alone."""
+    got = _probe_with(
+        monkeypatch, _fake_probe_torch(version="2.14.0.dev20260101", arches=_CU124_ARCHES)
+    )
+    assert got["status"] == "uncovered"
+    assert got["replaceable"] is False
+
+
+def test_probe_survives_a_broken_torch(monkeypatch) -> None:
+    """Never covered on uncertainty: a torch that raises must read as unknown."""
+    class Boom:
+        __version__ = "2.13.0+cu130"
+
+        def __getattr__(self, _name: str):
+            raise RuntimeError("broken install")
+
+    got = _probe_with(monkeypatch, Boom())
+    assert got["status"] == "unknown"
+    assert got["status"] != "covered"

{inline_core-1.2.64 → inline_core-1.2.65}/tests/test_minimaxh3_training.py

@@ -452,3 +452,26 @@ def test_long_enough_clip_encodes_on_the_frame_grid(tmp_path) -> None:
     frames = h3._clip_frames(clip, clip_frames=24)
     # Snapped down onto H3's 17n+5 grid rather than taking all 40.
     assert len(frames) == 22
+
+
+def test_clip_window_takes_the_tail_when_asked(tmp_path) -> None:
+    """The 17n+5 grid only snaps down, so part of every clip is dropped. A user whose action sits in
+    the last half second needs the tail rather than the head."""
+    from inline_core.training import h3
+
+    clip = _write_clip(tmp_path / "ramp.mp4", frames=40)
+    head = h3._clip_frames(clip, clip_frames=24, window="start")
+    tail = h3._clip_frames(clip, clip_frames=24, window="end")
+
+    assert len(head) == len(tail) == 22
+    # The fixture ramps brightness per frame, so the two windows cannot be the same footage.
+    assert head[0].getpixel((0, 0)) != tail[0].getpixel((0, 0))
+
+
+def test_clip_window_defaults_to_the_start(tmp_path) -> None:
+    from inline_core.training import h3
+
+    clip = _write_clip(tmp_path / "ramp2.mp4", frames=40)
+    assert h3._clip_frames(clip, clip_frames=24)[0].getpixel((0, 0)) == (
+        h3._clip_frames(clip, clip_frames=24, window="start")[0].getpixel((0, 0))
+    )

{inline_core-1.2.64 → inline_core-1.2.65}/tests/test_webui_install.py

@@ -60,15 +60,27 @@ class Sandbox:
         self.venv_python.parent.mkdir(parents=True, exist_ok=True)
         _stub(self.venv_python, 'echo "$*" >> "$PYTHON_LOG"\nexit 0\n')
 
-    def pretend_nvidia_gpu(self, *compute_caps: str) -> None:
+    def pretend_nvidia_gpu(self, *compute_caps: str, driver: str = "") -> None:
         """A driver that answers `-L` and the compute_cap query. Pass no caps for an older driver
-        that does not know the query, which is the case the fallback index exists for."""
-        answer = "".join(f"printf '{cap}\\n'\n" for cap in compute_caps) or "exit 1\n"
+        that does not know the query, which is the case the fallback index exists for.
+
+        `driver` fills the second CSV column; the launcher reads it for the R580 floor that decides
+        cu130 against frozen cu128."""
+        suffix = f", {driver}" if driver else ""
+        answer = "".join(f"printf '{cap}{suffix}\\n'\n" for cap in compute_caps) or "exit 1\n"
         _stub(
             self.stubs / "nvidia-smi",
             f'case "$*" in\n  *compute_cap*) {answer.strip()} ;;\nesac\nexit 0\n',
         )
 
+    def pretend_nvidia_probe_errors(self) -> None:
+        """A driver that lists GPUs but answers the query with an error string. The word must never
+        be coerced into a capability."""
+        _stub(
+            self.stubs / "nvidia-smi",
+            'case "$*" in\n  *compute_cap*) printf \'Unknown Error\\n\' ;;\nesac\nexit 0\n',
+        )
+
     def pretend_windows(self) -> None:
         """Only Windows needs an explicit CUDA index; this script runs there under Git Bash."""
         _stub(self.stubs / "uname", "printf 'MINGW64_NT-10.0-22631\\n'\nexit 0\n")
@@ -251,3 +263,76 @@ def test_launch_prefers_our_venv_over_the_active_environment(sandbox: Sandbox) -
     assert "FOREIGN" not in ran
     assert "-m inline_core.server" in ran
     assert "not the environment active in this shell" in done.stdout
+
+
+# --- the detect-only flag, and the decisions it reports -----------------------------------------
+#
+# Two field reports were unfalsifiable because the launcher printed a conclusion and never the
+# evidence. --print-torch-index prints both and installs nothing.
+
+
+def _decision(sandbox: Sandbox, *args: str) -> dict[str, str]:
+    result = sandbox.run("--print-torch-index", *args)
+    assert result.returncode == 0, result.stderr
+    out = {}
+    for line in result.stdout.splitlines():
+        key, _, value = line.partition(": ")
+        out[key] = value
+    return out
+
+
+def test_print_torch_index_installs_nothing(sandbox: Sandbox) -> None:
+    sandbox.pretend_windows()
+    sandbox.pretend_nvidia_gpu("12.0", driver="610.88")
+    _decision(sandbox)
+    assert sandbox.uv_calls() == []
+
+
+def test_blackwell_on_a_current_driver_gets_cu130(sandbox: Sandbox) -> None:
+    sandbox.pretend_windows()
+    sandbox.pretend_nvidia_gpu("12.0", driver="610.88")
+    got = _decision(sandbox)
+    assert got["torch-index"] == "cu130"
+    assert got["capability-major"] == "12"
+    assert got["reason"] == "autodetect"
+
+
+def test_blackwell_on_an_old_driver_gets_frozen_cu128(sandbox: Sandbox) -> None:
+    """CUDA 13 needs R580. cu128 still serves and was the first index with sm_120, so that machine
+    has exactly one workable choice and should not be made to type it back to us."""
+    sandbox.pretend_windows()
+    sandbox.pretend_nvidia_gpu("12.0", driver="575.57")
+    got = _decision(sandbox)
+    assert got["torch-index"] == "cu128"
+    assert got["reason"] == "driver-floor-cu128"
+
+
+def test_ada_gets_cu126(sandbox: Sandbox) -> None:
+    sandbox.pretend_windows()
+    sandbox.pretend_nvidia_gpu("8.9", driver="580.00")
+    assert _decision(sandbox)["torch-index"] == "cu126"
+
+
+def test_a_garbage_probe_falls_back_and_shows_its_working(sandbox: Sandbox) -> None:
+    """`Unknown Error` must not become a capability. A string comparison would rank it above 10 and
+    hand an unknown card cu130."""
+    sandbox.pretend_windows()
+    sandbox.pretend_nvidia_probe_errors()
+    got = _decision(sandbox)
+    assert got["torch-index"] == "cu126"
+    assert got["capability-major"] == "unknown"
+    assert "Unknown Error" in got["probe"]  # the raw line is echoed, not swallowed
+
+
+def test_no_gpu_reports_why(sandbox: Sandbox) -> None:
+    got = _decision(sandbox)
+    assert got["torch-index"] == "cpu"
+    assert got["reason"] == "no-gpu"
+
+
+def test_an_explicit_index_is_reported_as_an_override(sandbox: Sandbox) -> None:
+    sandbox.pretend_windows()
+    sandbox.pretend_nvidia_gpu("12.0", driver="610.88")
+    got = _decision(sandbox, "--torch-index", "cu126")
+    assert got["torch-index"] == "cu126"
+    assert got["reason"] == "override"