InvokeAI 6.14.1__tar.gz → 6.14.2__tar.gz

{invokeai-6.14.1 → invokeai-6.14.2}/InvokeAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: InvokeAI
-Version: 6.14.1
+Version: 6.14.2
 Summary: A full-featured AI-assisted image generation environment designed for creatives and enthusiasts.
 Author-email: Invoke <support@invoke.ai>
 License:                                  Apache License
@@ -247,6 +247,7 @@ Requires-Dist: dnspython
 Requires-Dist: dynamicprompts
 Requires-Dist: einops
 Requires-Dist: email-validator>=2.0.0
+Requires-Dist: fonttools[woff]
 Requires-Dist: passlib[bcrypt]>=1.7.4
 Requires-Dist: picklescan
 Requires-Dist: pillow

{invokeai-6.14.1 → invokeai-6.14.2}/InvokeAI.egg-info/SOURCES.txt

@@ -124,6 +124,7 @@ invokeai/app/invocations/krea2_denoise.py
 invokeai/app/invocations/krea2_lora_loader.py
 invokeai/app/invocations/krea2_model_loader.py
 invokeai/app/invocations/krea2_seed_variance.py
+invokeai/app/invocations/krea2_style_reference.py
 invokeai/app/invocations/krea2_text_encoder.py
 invokeai/app/invocations/latent_noise.py
 invokeai/app/invocations/latents_to_image.py
@@ -475,6 +476,7 @@ invokeai/app/util/dynamicprompts.py
 invokeai/app/util/metaenum.py
 invokeai/app/util/misc.py
 invokeai/app/util/model_exclude_null.py
+invokeai/app/util/path_safety.py
 invokeai/app/util/profiler.py
 invokeai/app/util/ssrf.py
 invokeai/app/util/startup_utils.py
@@ -659,6 +661,10 @@ invokeai/backend/krea2/__init__.py
 invokeai/backend/krea2/attention.py
 invokeai/backend/krea2/regional_prompting.py
 invokeai/backend/krea2/sampling_utils.py
+invokeai/backend/krea2/style_reference.py
+invokeai/backend/krea2/style_reference_extension.py
+invokeai/backend/krea2/style_reference_rf.py
+invokeai/backend/krea2/text_encoding.py
 invokeai/backend/krea2/vae_compat.py
 invokeai/backend/model_hash/hash_validator.py
 invokeai/backend/model_hash/model_hash.py
@@ -933,6 +939,7 @@ invokeai/backend/util/mask.py
 invokeai/backend/util/original_weights_storage.py
 invokeai/backend/util/prefix_logger_adapter.py
 invokeai/backend/util/silence_warnings.py
+invokeai/backend/util/state_dict_loading.py
 invokeai/backend/util/test_utils.py
 invokeai/backend/util/util.py
 invokeai/backend/util/vae_working_memory.py
@@ -975,12 +982,12 @@ invokeai/frontend/install/__init__.py
 invokeai/frontend/install/import_images.py
 invokeai/frontend/web/__init__.py
 invokeai/frontend/web/dist/index.html
-invokeai/frontend/web/dist/assets/App-CKkzUo1u.js
+invokeai/frontend/web/dist/assets/App-DvlZKGz7.js
 invokeai/frontend/web/dist/assets/App-tn1JZtBo.css
 invokeai/frontend/web/dist/assets/browser-ponyfill-BpMPqZAt.js
 invokeai/frontend/web/dist/assets/chunk-jRWAZmH_.js
 invokeai/frontend/web/dist/assets/denoising-strength-4mznP2tj.png
-invokeai/frontend/web/dist/assets/index-BRHi9LIu.js
+invokeai/frontend/web/dist/assets/index-BuK6cFYB.js
 invokeai/frontend/web/dist/assets/inter-cyrillic-ext-wght-normal-BOeWTOD4.woff2
 invokeai/frontend/web/dist/assets/inter-cyrillic-wght-normal-DqGufNeO.woff2
 invokeai/frontend/web/dist/assets/inter-greek-ext-wght-normal-DlzME5K_.woff2

{invokeai-6.14.1 → invokeai-6.14.2}/InvokeAI.egg-info/requires.txt

@@ -31,6 +31,7 @@ dnspython
 dynamicprompts
 einops
 email-validator>=2.0.0
+fonttools[woff]
 passlib[bcrypt]>=1.7.4
 picklescan
 pillow

{invokeai-6.14.1 → invokeai-6.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: InvokeAI
-Version: 6.14.1
+Version: 6.14.2
 Summary: A full-featured AI-assisted image generation environment designed for creatives and enthusiasts.
 Author-email: Invoke <support@invoke.ai>
 License:                                  Apache License
@@ -247,6 +247,7 @@ Requires-Dist: dnspython
 Requires-Dist: dynamicprompts
 Requires-Dist: einops
 Requires-Dist: email-validator>=2.0.0
+Requires-Dist: fonttools[woff]
 Requires-Dist: passlib[bcrypt]>=1.7.4
 Requires-Dist: picklescan
 Requires-Dist: pillow

{invokeai-6.14.1 → invokeai-6.14.2}/invokeai/app/api/routers/model_manager.py

@@ -7,6 +7,7 @@ import io
 import pathlib
 import threading
 import traceback
+import unicodedata
 from collections.abc import Generator
 from copy import deepcopy
 from enum import Enum
@@ -24,7 +25,10 @@ from typing_extensions import Annotated
 
 from invokeai.app.api.auth_dependencies import AdminUserOrDefault, CurrentUserOrDefault
 from invokeai.app.api.dependencies import ApiDependencies
-from invokeai.app.services.model_images.model_images_common import ModelImageFileNotFoundException
+from invokeai.app.services.model_images.model_images_common import (
+    ModelImageFileDeleteException,
+    ModelImageFileNotFoundException,
+)
 from invokeai.app.services.model_install.model_install_common import ModelInstallJob
 from invokeai.app.services.model_records import (
     InvalidModelException,
@@ -34,6 +38,7 @@ from invokeai.app.services.model_records import (
 )
 from invokeai.app.services.orphaned_models import CONVERSION_SCRATCH_DIRNAME, OrphanedModelInfo
 from invokeai.app.services.shared.sqlite.sqlite_common import SQLiteDirection
+from invokeai.app.util.path_safety import is_plain_filename
 from invokeai.app.util.suppress_output import SuppressOutput
 from invokeai.backend.model_manager.configs.external_api import ExternalApiModelConfig
 from invokeai.backend.model_manager.configs.factory import AnyModelConfig, ModelConfigFactory
@@ -77,6 +82,18 @@ _MODEL_KEY_CLAIM_LOCK = threading.Lock()
 _CLAIMED_MODEL_KEYS: set[str] = set()
 
 
+def _claim_token(key: str) -> str:
+    """The form of a key recorded in `_CLAIMED_MODEL_KEYS`.
+
+    A model's cover image is stored as `<key>.webp`, and some filesystems map different strings to one file: the
+    macOS and Windows defaults are case-insensitive, and APFS also ignores Unicode normalization, so `\u00e9` and
+    `e\u0301` name the same entry. Claims use Unicode canonical caseless matching (NFD, casefold, NFD) so that such a
+    variant of a key cannot slip past a claim held on the key itself and touch that file. Two keys that are
+    distinct on disk but equal under this form would at worst serialize against each other.
+    """
+    return unicodedata.normalize("NFD", unicodedata.normalize("NFD", key).casefold())
+
+
 @contextlib.contextmanager
 def _claim_model_key(key: str) -> Generator[None, None, None]:
     """Hold the exclusive claim on one model key, or raise 409 if another request holds it."""
@@ -87,20 +104,21 @@ def _claim_model_key(key: str) -> Generator[None, None, None]:
             status_code=409,
             detail="Another model operation is already in progress. Wait for it to finish and try again.",
         )
+    token = _claim_token(key)
     try:
-        if key in _CLAIMED_MODEL_KEYS:
+        if token in _CLAIMED_MODEL_KEYS:
             raise HTTPException(
                 status_code=409,
                 detail=f"Another operation on model {key} is already in progress. Wait for it to finish and try again.",
             )
-        _CLAIMED_MODEL_KEYS.add(key)
+        _CLAIMED_MODEL_KEYS.add(token)
     finally:
         _MODEL_KEY_CLAIM_LOCK.release()
     try:
         yield
     finally:
         with _MODEL_KEY_CLAIM_LOCK:
-            _CLAIMED_MODEL_KEYS.discard(key)
+            _CLAIMED_MODEL_KEYS.discard(token)
 
 
 @contextlib.contextmanager
@@ -112,17 +130,18 @@ def _install_and_claim_model(
     # request claims so a delete cannot observe the new record before its key is claimed.
     with _MODEL_KEY_CLAIM_LOCK:
         new_key = installer.install_path(model_path, config=config)
-        if new_key in _CLAIMED_MODEL_KEYS:
+        token = _claim_token(new_key)
+        if token in _CLAIMED_MODEL_KEYS:
             raise HTTPException(
                 status_code=409,
                 detail=f"Another operation on model {new_key} is already in progress. Wait for it to finish and try again.",
             )
-        _CLAIMED_MODEL_KEYS.add(new_key)
+        _CLAIMED_MODEL_KEYS.add(token)
     try:
         yield new_key
     finally:
         with _MODEL_KEY_CLAIM_LOCK:
-            _CLAIMED_MODEL_KEYS.discard(new_key)
+            _CLAIMED_MODEL_KEYS.discard(token)
 
 
 # The HF token is process-global state backed by a file in the HF cache. Concurrent writers would
@@ -580,6 +599,13 @@ async def update_model_record(
     current_admin: AdminUserOrDefault,
 ) -> AnyModelConfig:
     """Update a model's config."""
+    # The key identifies the row; it is not an editable field, and there is no UI to change one. The edit form
+    # does post the record back whole, so an unchanged echo is expected and accepted - but a *different* key is
+    # written into the stored config while the row id keeps the old one, which leaves a record that answers to a
+    # key nothing can look it up by: `replace_model` (and so reidentify) raises `UnknownModelException` forever
+    # after, and the UI caches the model under the new key so every later request for it 404s.
+    if "key" in changes.model_fields_set and changes.key != key:
+        raise HTTPException(status_code=422, detail="A model's key cannot be changed")
     return await asyncio.to_thread(_update_model_record, key, changes)
 
 
@@ -643,6 +669,7 @@ def get_model_image(
             "description": "The model image was updated successfully",
         },
         400: {"description": "Bad request"},
+        404: {"description": "The model could not be found"},
         409: {"description": "Another operation on this model is already in progress"},
     },
     status_code=200,
@@ -660,6 +687,25 @@ async def update_model_image(
     # A conversion moves this model's image to the replacement's key when it finishes, so claim
     # the key before reading the upload and hold it until the image is saved.
     with _claim_model_key(key):
+        # The image is stored in a file named after the key, so a key that names no model would have us write a
+        # stray file - and a key that is not a plain filename would have us write it outside the images folder.
+        # Resolving the record turns both into a 404 instead. It has to happen under the claim: the delete and
+        # convert routes claim the key too, so they cannot remove the record between this check and the save.
+        # (Removing an external provider's models in `app_info.py` does not take the claim, so that path can
+        # still leave an orphan image - which the image-delete route below can clean up.)
+        try:
+            ApiDependencies.invoker.services.model_manager.store.get_model(key)
+        except UnknownModelException as e:
+            raise HTTPException(status_code=404, detail=str(e))
+
+        # A record written before install requests had their keys validated can still carry a key that is not a
+        # plain filename. The storage service refuses to build a path from it; ask it now, so that is a 404
+        # rather than a save failure surfacing as a 500 after the upload has been read.
+        try:
+            model_images.get_path(key)
+        except ModelImageFileNotFoundException as e:
+            raise HTTPException(status_code=404, detail=str(e))
+
         contents = await image.read()
         try:
             pil_image = await asyncio.to_thread(Image.open, io.BytesIO(contents))
@@ -847,13 +893,17 @@ def delete_model_image(
     # Claimed for the same reason as the upload: a conversion carries this model's image over to
     # the replacement's key, so a delete accepted meanwhile is undone by that copy.
     with _claim_model_key(key):
+        # Unlike the upload, this does not require the model's record: deleting a model leaves its image
+        # behind, and this route is how that orphan gets cleaned up. The storage service rejects a key that
+        # is not a plain filename, and that - like a missing file - is a 404.
         try:
             model_images.delete(key)
             logger.info(f"Deleted model image: {key}")
             return
-        except UnknownModelException as e:
-            logger.error(str(e))
-            raise HTTPException(status_code=404, detail=str(e))
+        except ModelImageFileDeleteException as e:
+            if isinstance(e.__cause__, ModelImageFileNotFoundException):
+                raise HTTPException(status_code=404, detail=str(e.__cause__))
+            raise
 
 
 @model_manager_router.post(
@@ -906,6 +956,12 @@ def install_model(
     """
     logger = ApiDependencies.invoker.services.logger
 
+    # A caller may name the key it wants, and the key names the directory the model is moved into and the file its
+    # cover image is written to. Reject an unusable one here, where it is being chosen, rather than letting the
+    # install fail later at one of those joins. Existing records are not held to this - see `ModelRecordChanges.key`.
+    if config.key is not None and not is_plain_filename(config.key):
+        raise HTTPException(status_code=422, detail=f"Invalid model key {config.key!r}: it must be a plain filename")
+
     try:
         installer = ApiDependencies.invoker.services.model_manager.install
         result: ModelInstallJob = installer.heuristic_import(

{invokeai-6.14.1 → invokeai-6.14.2}/invokeai/app/api/routers/utilities.py

@@ -1,13 +1,18 @@
 import asyncio
 import logging
+import re
 import threading
 from pathlib import Path
 from typing import Optional, Union
+from urllib.parse import quote
 
 import torch
 from dynamicprompts.generators import CombinatorialPromptGenerator, RandomPromptGenerator
 from fastapi import Body, HTTPException
+from fastapi.responses import FileResponse
 from fastapi.routing import APIRouter
+from fontTools.ttLib import TTFont
+from PIL import ImageFont
 from pydantic import BaseModel, Field
 from pyparsing import ParseException
 from transformers import AutoProcessor, AutoTokenizer, LlavaOnevisionForConditionalGeneration, LlavaOnevisionProcessor
@@ -29,6 +34,14 @@ from invokeai.backend.util.devices import TorchDevice
 logger = logging.getLogger(__name__)
 
 utilities_router = APIRouter(prefix="/v1/utilities", tags=["utilities"])
+SUPPORTED_FONT_EXTENSIONS = {".ttf", ".otf", ".woff", ".woff2"}
+FONT_MEDIA_TYPES = {
+    ".ttf": "font/ttf",
+    ".otf": "font/otf",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+}
+FONT_CACHE_CONTROL = "private, max-age=31536000, immutable"
 
 # The underlying model loader is not thread-safe, so we serialize load_model calls.
 _model_load_lock = threading.Lock()
@@ -39,6 +52,26 @@ class DynamicPromptsResponse(BaseModel):
     error: Optional[str] = None
 
 
+class UserFontFace(BaseModel):
+    path: str
+    url: str
+    weight: int
+    style: str
+
+
+class UserFont(BaseModel):
+    id: str
+    family: str
+    label: str
+    path: str
+    url: str
+    faces: list[UserFontFace]
+
+
+class UserFontsResponse(BaseModel):
+    fonts: list[UserFont]
+
+
 @utilities_router.post(
     "/dynamicprompts",
     operation_id="parse_dynamicprompts",
@@ -81,6 +114,257 @@ def parse_dynamicprompts(
     return DynamicPromptsResponse(prompts=prompts if prompts else [""], error=error)
 
 
+def _get_fonts_dir() -> Path:
+    return ApiDependencies.invoker.services.configuration.fonts_path
+
+
+def _path_has_symlink_component(path: Path, boundary: Path) -> bool:
+    current = path
+    boundary = boundary.absolute()
+    try:
+        current.absolute().relative_to(boundary)
+    except ValueError:
+        return True
+
+    while True:
+        if current.is_symlink():
+            return True
+        if current == boundary:
+            return False
+        current = current.parent
+
+
+def _get_name_table_value(font: TTFont, name_ids: tuple[int, ...]) -> str | None:
+    if "name" not in font:
+        return None
+
+    def _sort_key(record: object) -> tuple[int, int]:
+        platform_id = getattr(record, "platformID", -1)
+        lang_id = getattr(record, "langID", -1)
+        if platform_id == 3 and lang_id in (0x0409, 0):
+            return (0, 0)
+        if platform_id == 3:
+            return (1, 0)
+        if platform_id == 0:
+            return (2, 0)
+        return (3, lang_id)
+
+    records = font["name"].names
+    for name_id in name_ids:
+        for record in sorted((record for record in records if record.nameID == name_id), key=_sort_key):
+            try:
+                value = record.toUnicode().strip()
+            except Exception:
+                continue
+            if value:
+                return value
+    return None
+
+
+def _normalize_variant_text(value: str) -> str:
+    value = re.sub(r"(?<=[a-z])(?=[A-Z])", " ", value)
+    value = value.replace("_", " ").replace("-", " ")
+    value = re.sub(r"\s+", " ", value)
+    return value.strip().lower()
+
+
+def _infer_font_weight(style_name: str, file_stem: str, weight_class: int | None) -> int:
+    if isinstance(weight_class, int) and 1 <= weight_class <= 1000:
+        return weight_class
+
+    combined = _normalize_variant_text(f"{style_name} {file_stem}")
+    # Ordering matters: more specific keywords must be matched before "bold".
+    weight_keywords = [
+        (("thin", "hairline"), 100),
+        (("extra light", "ultra light", "extralight", "ultralight"), 200),
+        (("light",), 300),
+        (("normal", "regular", "roman", "book"), 400),
+        (("medium",), 500),
+        (("semi bold", "semibold", "demi bold", "demibold"), 600),
+        (("extra bold", "ultra bold", "extrabold", "ultrabold"), 800),
+        (("black", "heavy"), 900),
+        (("bold",), 700),
+    ]
+    for keywords, weight in weight_keywords:
+        if any(keyword in combined for keyword in keywords):
+            return weight
+
+    return 400
+
+
+def _infer_font_style(style_name: str, file_stem: str, italic_flag: bool) -> str:
+    if italic_flag:
+        return "italic"
+
+    combined = _normalize_variant_text(f"{style_name} {file_stem}")
+    if "italic" in combined or "oblique" in combined:
+        return "italic"
+
+    return "normal"
+
+
+def _get_font_metadata(font_file: Path) -> tuple[str, str, int, str] | None:
+    ttfont_error: Exception | None = None
+    try:
+        with TTFont(font_file.as_posix(), lazy=True) as font:
+            family_name = (_get_name_table_value(font, (16, 1)) or "").strip()
+            style_name = (_get_name_table_value(font, (17, 2)) or "").strip()
+            os2_table = font["OS/2"] if "OS/2" in font else None
+            head_table = font["head"] if "head" in font else None
+            post_table = font["post"] if "post" in font else None
+            weight_class = getattr(os2_table, "usWeightClass", None)
+            italic_flag = bool(getattr(os2_table, "fsSelection", 0) & 0x01) or bool(
+                getattr(head_table, "macStyle", 0) & 0x02
+            )
+            if post_table is not None:
+                italic_flag = italic_flag or bool(getattr(post_table, "italicAngle", 0))
+            if family_name:
+                return (
+                    family_name,
+                    family_name,
+                    _infer_font_weight(style_name, font_file.stem, weight_class),
+                    _infer_font_style(style_name, font_file.stem, italic_flag),
+                )
+    except Exception as e:
+        ttfont_error = e
+
+    try:
+        font = ImageFont.truetype(font_file.as_posix(), size=16)
+        family_name, style_name = font.getname()
+        family_name = family_name.strip()
+        style_name = style_name.strip()
+        if family_name:
+            return (
+                family_name,
+                family_name,
+                _infer_font_weight(style_name, font_file.stem, None),
+                _infer_font_style(style_name, font_file.stem, False),
+            )
+    except Exception as e:
+        logger.warning(
+            "Skipping font file %s: unable to read font metadata with fontTools or Pillow (%s, %s)",
+            font_file,
+            type(ttfont_error).__name__ if ttfont_error else "no-fontTools-error",
+            type(e).__name__,
+            exc_info=e,
+        )
+        return None
+
+    logger.warning("Skipping font file %s: missing font family metadata", font_file)
+    return None
+
+
+def _resolve_font_request_path(font_path: str) -> Path:
+    fonts_dir = _get_fonts_dir()
+    if not fonts_dir.exists() or not fonts_dir.is_dir():
+        raise HTTPException(status_code=404, detail="Font file not found")
+
+    requested = (fonts_dir / font_path).absolute()
+    if _path_has_symlink_component(requested, fonts_dir):
+        raise HTTPException(status_code=400, detail="Invalid font path")
+
+    resolved_fonts_dir = fonts_dir.resolve()
+    resolved_requested = requested.resolve()
+
+    try:
+        resolved_requested.relative_to(resolved_fonts_dir)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail="Invalid font path") from e
+
+    return resolved_requested
+
+
+@utilities_router.get(
+    "/fonts",
+    operation_id="list_user_fonts",
+    responses={200: {"model": UserFontsResponse}},
+)
+def list_user_fonts(_current_user: CurrentUserOrDefault) -> UserFontsResponse:
+    fonts_dir = _get_fonts_dir()
+    if not fonts_dir.exists() or not fonts_dir.is_dir() or fonts_dir.is_symlink():
+        if fonts_dir.is_symlink():
+            logger.warning("Skipping custom fonts directory %s: symlinks are not supported", fonts_dir)
+        return UserFontsResponse(fonts=[])
+
+    family_candidates: dict[str, list[tuple[Path, str, str, int, str]]] = {}
+    # key -> [(font_file, relative, family, weight, style)]
+    for font_file in sorted(fonts_dir.rglob("*")):
+        if _path_has_symlink_component(font_file.absolute(), fonts_dir):
+            logger.warning("Skipping font path %s: symlinks are not supported", font_file)
+            continue
+        if not font_file.is_file() or font_file.suffix.lower() not in SUPPORTED_FONT_EXTENSIONS:
+            continue
+        relative = font_file.relative_to(fonts_dir).as_posix()
+        metadata = _get_font_metadata(font_file)
+        if metadata is None:
+            continue
+        family, _label, weight, style = metadata
+        family_key = family.strip().lower()
+        family_candidates.setdefault(family_key, []).append((font_file, relative, family, weight, style))
+
+    def _candidate_score(weight: int, style: str, path: Path) -> tuple[int, int, int]:
+        """Lower score is better. Prefer regular/normal faces, then shorter names."""
+        return (0 if style == "normal" else 1, abs(weight - 400), len(path.stem))
+
+    fonts: list[UserFont] = []
+    for family_key, candidates in sorted(family_candidates.items(), key=lambda kv: kv[0]):
+        _, selected_relative, selected_family, _, _ = min(candidates, key=lambda c: _candidate_score(c[3], c[4], c[0]))
+        faces_by_variant: dict[tuple[int, str], tuple[Path, str, str, int, str]] = {}
+        for candidate in candidates:
+            variant_key = (candidate[3], candidate[4])
+            current = faces_by_variant.get(variant_key)
+            if current is None or _candidate_score(candidate[3], candidate[4], candidate[0]) < _candidate_score(
+                current[3], current[4], current[0]
+            ):
+                faces_by_variant[variant_key] = candidate
+
+        faces = [
+            UserFontFace(
+                path=relative,
+                url=f"api/v1/utilities/fonts/{quote(relative)}",
+                weight=weight,
+                style=style,
+            )
+            for (weight, style), (_, relative, _, _, _) in sorted(
+                faces_by_variant.items(), key=lambda item: (item[0][1] != "normal", abs(item[0][0] - 400), item[0][0])
+            )
+        ]
+
+        fonts.append(
+            UserFont(
+                id=f"user:{family_key}",
+                family=selected_family,
+                label=selected_family,
+                path=selected_relative,
+                url=f"api/v1/utilities/fonts/{quote(selected_relative)}",
+                faces=faces,
+            )
+        )
+
+    return UserFontsResponse(fonts=fonts)
+
+
+@utilities_router.get(
+    "/fonts/{font_path:path}",
+    operation_id="get_user_font_file",
+)
+def get_user_font_file(font_path: str, _current_user: CurrentUserOrDefault) -> FileResponse:
+    requested = _resolve_font_request_path(font_path)
+    if not requested.exists() or not requested.is_file():
+        raise HTTPException(status_code=404, detail="Font file not found")
+
+    if requested.suffix.lower() not in SUPPORTED_FONT_EXTENSIONS:
+        raise HTTPException(status_code=400, detail="Unsupported font format")
+
+    return FileResponse(
+        path=requested,
+        media_type=FONT_MEDIA_TYPES[requested.suffix.lower()],
+        filename=requested.name,
+        content_disposition_type="inline",
+        headers={"Cache-Control": FONT_CACHE_CONTROL},
+    )
+
+
 # --- Expand Prompt ---
 
 
@@ -257,7 +541,7 @@ def _run_image_to_prompt(
     with _model_load_lock:
         loaded_model = model_manager.load.load_model(model_config, user_id=user_id)
 
-    # Load the image from InvokeAI's image store
+    # Load the image from InvokeAI's image store.
     image = ApiDependencies.invoker.services.images.get_pil_image(image_name)
     image = image.convert("RGB")
 

{invokeai-6.14.1 → invokeai-6.14.2}/invokeai/app/api/routers/videos.py

@@ -215,8 +215,12 @@ class _VideoUploadStreamParser:
         self._header_value = bytearray()
         self._headers: dict[bytes, bytes] = {}
         self._part_name: Optional[bytes] = None
-        self._metadata_chunks: list[bytes] = []
-        self._metadata_size = 0
+        # A bytearray, not a list of per-callback chunks: the parser hands the metadata
+        # field over in whatever pieces the client sent it, and one `bytes` object per
+        # piece would let a client that dribbles the field in 2-byte pieces hold ~22x the
+        # size cap in memory. `len(self._metadata)` is the retained size, so the cap
+        # below bounds memory, not just payload.
+        self._metadata = bytearray()
         self.filename: Optional[str] = None
         self.content_type: Optional[str] = None
         self.metadata: Optional[str] = None
@@ -247,8 +251,7 @@ class _VideoUploadStreamParser:
         self._header_field = bytearray()
         self._header_value = bytearray()
         self._part_name = None
-        self._metadata_chunks = []
-        self._metadata_size = 0
+        self._metadata = bytearray()
 
     def _on_header_field(self, data: bytes, start: int, end: int) -> None:
         self._header_field.extend(data[start:end])
@@ -288,25 +291,23 @@ class _VideoUploadStreamParser:
                 )
             self._destination.write(chunk)
         elif self._part_name == b"metadata":
-            self._metadata_size += len(chunk)
-            if self._metadata_size > MAX_UPLOAD_METADATA_SIZE:
+            if len(self._metadata) + len(chunk) > MAX_UPLOAD_METADATA_SIZE:
                 raise HTTPException(
                     status_code=413,
                     detail=f"Video metadata exceeds maximum size ({MAX_UPLOAD_METADATA_SIZE} bytes)",
                 )
-            self._metadata_chunks.append(chunk)
+            self._metadata.extend(chunk)
         # Any other field is dropped rather than buffered: an unknown part must not be a
         # way to make the server hold arbitrary bytes in memory.
 
     def _on_part_end(self) -> None:
         if self._part_name == b"metadata":
             try:
-                self.metadata = b"".join(self._metadata_chunks).decode("utf-8")
+                self.metadata = self._metadata.decode("utf-8")
             except UnicodeDecodeError as error:
                 raise HTTPException(status_code=422, detail="Metadata must be UTF-8 encoded") from error
         self._part_name = None
-        self._metadata_chunks = []
-        self._metadata_size = 0
+        self._metadata = bytearray()
 
     def _on_end(self) -> None:
         self.saw_end = True