dsh-plugin-image-workbench 1.1.5 → 1.1.6

package/vendor/chatgpt2api/source/utils/image_tokens.py

@@ -1,346 +1,346 @@
-from __future__ import annotations
-
-import base64
-import math
-import re
-from io import BytesIO
-from typing import Any
-
-from PIL import Image
-
-DEFAULT_IMAGE_SIZE = (1024, 1024)
-IMAGE_INPUT_TOKEN_MODEL = "gpt-5.4-mini"
-
-PATCH_SIZE = 32
-TILE_SIZE = 512
-TILE_HIGH_SHORT_SIDE = 768
-
-PATCH_1536_MODELS = (
-    "gpt-5.4-mini",
-    "gpt-5.4-nano",
-    "gpt-5-mini",
-    "gpt-5-nano",
-    "gpt-5.2",
-    "gpt-5.3-codex",
-    "gpt-5-codex-mini",
-    "gpt-5.1-codex-mini",
-    "gpt-5.2-codex",
-    "gpt-5.2-chat-latest",
-    "o4-mini",
-    "gpt-4.1-mini",
-    "gpt-4.1-nano",
-)
-
-PATCH_MULTIPLIERS = {
-    "gpt-5.4-mini": 1.62,
-    "gpt-5.4-nano": 2.46,
-    "gpt-5-mini": 1.62,
-    "gpt-5-nano": 2.46,
-    "gpt-4.1-mini": 1.62,
-    "gpt-4.1-nano": 2.46,
-    "o4-mini": 1.72,
-}
-
-
-def _model_name(model: str) -> str:
-    return str(model or "").strip().lower()
-
-
-def image_size_from_bytes(data: bytes) -> tuple[int, int] | None:
-    if not data:
-        return None
-    try:
-        with Image.open(BytesIO(data)) as image:
-            width, height = image.size
-    except Exception:
-        return None
-    if width <= 0 or height <= 0:
-        return None
-    return int(width), int(height)
-
-
-def _decode_data_url(value: str) -> bytes:
-    text = str(value or "").strip()
-    payload = text.split(",", 1)[1] if text.startswith("data:") and "," in text else text
-    return base64.b64decode(payload)
-
-
-def image_size_from_data_url(value: str) -> tuple[int, int] | None:
-    try:
-        return image_size_from_bytes(_decode_data_url(value))
-    except Exception:
-        return None
-
-
-def parse_image_size(size: object, default: tuple[int, int] = DEFAULT_IMAGE_SIZE) -> tuple[int, int]:
-    if isinstance(size, (tuple, list)) and len(size) >= 2:
-        try:
-            width = int(size[0])
-            height = int(size[1])
-            if width > 0 and height > 0:
-                return width, height
-        except (TypeError, ValueError):
-            pass
-    match = re.search(r"(\d{2,5})\D+(\d{2,5})", str(size or ""))
-    if not match:
-        return default
-    width, height = int(match.group(1)), int(match.group(2))
-    return (width, height) if width > 0 and height > 0 else default
-
-
-def _patch_count(width: float, height: float) -> int:
-    return math.ceil(width / PATCH_SIZE) * math.ceil(height / PATCH_SIZE)
-
-
-def _patch_multiplier(model: str) -> float:
-    name = _model_name(model)
-    for prefix, multiplier in PATCH_MULTIPLIERS.items():
-        if name.startswith(prefix):
-            return multiplier
-    return 1.0
-
-
-def _patch_limits(model: str, detail: str) -> tuple[int, int] | None:
-    name = _model_name(model)
-    if any(name.startswith(prefix) for prefix in PATCH_1536_MODELS):
-        return 1536, 2048
-    if name.startswith("gpt-5.5"):
-        return (10000, 6000) if detail in {"auto", "original"} else (2500, 2048)
-    if name.startswith("gpt-5.4"):
-        return (10000, 6000) if detail == "original" else (2500, 2048)
-    return None
-
-
-def _patch_tokens(width: int, height: int, model: str, detail: str) -> int:
-    multiplier = _patch_multiplier(model)
-    if detail == "low":
-        return math.ceil(256 * multiplier)
-
-    limits = _patch_limits(model, detail)
-    if limits is None:
-        return 0
-    patch_budget, max_dimension = limits
-    scale = min(1.0, max_dimension / max(width, height))
-    resized_width = width * scale
-    resized_height = height * scale
-
-    if _patch_count(resized_width, resized_height) > patch_budget:
-        shrink_factor = math.sqrt((PATCH_SIZE * PATCH_SIZE * patch_budget) / (resized_width * resized_height))
-        width_units = resized_width * shrink_factor / PATCH_SIZE
-        height_units = resized_height * shrink_factor / PATCH_SIZE
-        adjusted_shrink_factor = shrink_factor * min(
-            math.floor(width_units) / width_units if width_units else 1,
-            math.floor(height_units) / height_units if height_units else 1,
-        )
-        resized_width *= adjusted_shrink_factor
-        resized_height *= adjusted_shrink_factor
-
-    tokens = min(_patch_count(max(1, resized_width), max(1, resized_height)), patch_budget)
-    return math.ceil(tokens * multiplier)
-
-
-def _tile_rates(model: str) -> tuple[int, int]:
-    name = _model_name(model)
-    if name in {"gpt-5", "gpt-5-chat-latest"}:
-        return 70, 140
-    if name.startswith("gpt-4o-mini"):
-        return 2833, 5667
-    if name.startswith(("o1", "o1-pro", "o3")):
-        return 75, 150
-    if name.startswith("computer-use-preview"):
-        return 65, 129
-    return 85, 170
-
-
-def _tile_tokens(width: int, height: int, model: str, detail: str) -> int:
-    base_tokens, tile_tokens = _tile_rates(model)
-    if detail == "low":
-        return base_tokens
-
-    scale = min(1.0, 2048 / max(width, height))
-    resized_width = width * scale
-    resized_height = height * scale
-    short_side = min(resized_width, resized_height)
-    if short_side > 0:
-        scale = TILE_HIGH_SHORT_SIDE / short_side
-        resized_width *= scale
-        resized_height *= scale
-
-    tiles = math.ceil(resized_width / TILE_SIZE) * math.ceil(resized_height / TILE_SIZE)
-    return base_tokens + tiles * tile_tokens
-
-
-def count_image_input_tokens(
-    width: int,
-    height: int,
-    model: str,
-    detail: str = "auto",
-    input_fidelity: str = "low",
-) -> int:
-    if width <= 0 or height <= 0:
-        return 0
-    detail = str(detail or "auto").strip().lower() or "auto"
-    return _patch_tokens(width, height, IMAGE_INPUT_TOKEN_MODEL, detail)
-
-
-def _part_size(part: dict[str, Any]) -> tuple[int, int] | None:
-    try:
-        width = int(part.get("width") or 0)
-        height = int(part.get("height") or 0)
-    except (TypeError, ValueError):
-        width = height = 0
-    if width > 0 and height > 0:
-        return width, height
-
-    data = part.get("data")
-    if isinstance(data, (bytes, bytearray)):
-        return image_size_from_bytes(bytes(data))
-
-    image_url = part.get("image_url")
-    if isinstance(image_url, dict):
-        image_url = image_url.get("url") or image_url.get("image_url")
-    if isinstance(image_url, str) and image_url.startswith("data:"):
-        return image_size_from_data_url(image_url)
-
-    source = part.get("source")
-    if isinstance(source, dict) and str(source.get("type") or "") == "base64":
-        try:
-            return image_size_from_bytes(base64.b64decode(str(source.get("data") or "")))
-        except Exception:
-            return None
-    return None
-
-
-def count_image_content_tokens(content: object, model: str, default_detail: str = "auto") -> int:
-    if not isinstance(content, list):
-        return 0
-    total = 0
-    for part in content:
-        if not isinstance(part, dict):
-            continue
-        part_type = str(part.get("type") or "").strip()
-        if part_type not in {"image", "image_url", "input_image"} and not part.get("source"):
-            continue
-        size = _part_size(part)
-        if not size:
-            continue
-        total += count_image_input_tokens(
-            size[0],
-            size[1],
-            model,
-            str(part.get("detail") or default_detail or "auto"),
-            str(part.get("input_fidelity") or part.get("inputFidelity") or "low"),
-        )
-    return total
-
-
-def count_image_inputs_tokens(images: object, model: str, default_detail: str = "auto") -> int:
-    if not images:
-        return 0
-    total = 0
-    entries = images if isinstance(images, list) else [images]
-    for image in entries:
-        data = image[0] if isinstance(image, tuple) and image else image
-        if not isinstance(data, (bytes, bytearray)):
-            continue
-        size = image_size_from_bytes(bytes(data))
-        if size:
-            total += count_image_input_tokens(size[0], size[1], model, default_detail)
-    return total
-
-
-def count_generated_image_tokens(width: int, height: int, quality: str = "auto") -> int:
-    patches = _patch_count(width, height)
-    quality = str(quality or "auto").strip().lower()
-    if quality == "low":
-        return math.ceil(patches * 17 / 64)
-    if quality in {"high", "hd"}:
-        return math.ceil(patches * 65 / 16)
-    return math.ceil(patches * 33 / 32)
-
-
-def count_image_output_tokens(size: object = None, quality: str = "auto", count: int = 1) -> int:
-    width, height = parse_image_size(size)
-    return max(0, int(count or 0)) * count_generated_image_tokens(width, height, quality)
-
-
-def count_image_output_items_tokens(
-    items: object,
-    size: object = None,
-    quality: str = "auto",
-) -> int:
-    if not isinstance(items, list) or not items:
-        return 0
-    fallback_size = parse_image_size(size)
-    total = 0
-    for item in items:
-        image_size = None
-        if isinstance(item, dict):
-            b64_json = str(item.get("b64_json") or "").strip()
-            if b64_json:
-                try:
-                    image_size = image_size_from_bytes(base64.b64decode(b64_json))
-                except Exception:
-                    image_size = None
-        width, height = image_size or fallback_size
-        total += count_generated_image_tokens(width, height, quality)
-    return total
-
-
-def token_usage(
-    input_text_tokens: int = 0,
-    input_image_tokens: int = 0,
-    output_text_tokens: int = 0,
-    output_image_tokens: int = 0,
-) -> dict[str, Any]:
-    input_tokens = max(0, int(input_text_tokens or 0)) + max(0, int(input_image_tokens or 0))
-    output_tokens = max(0, int(output_text_tokens or 0)) + max(0, int(output_image_tokens or 0))
-    return {
-        "input_tokens": input_tokens,
-        "output_tokens": output_tokens,
-        "total_tokens": input_tokens + output_tokens,
-        "input_tokens_details": {
-            "text_tokens": max(0, int(input_text_tokens or 0)),
-            "image_tokens": max(0, int(input_image_tokens or 0)),
-            "cached_tokens": 0,
-        },
-        "output_tokens_details": {
-            "text_tokens": max(0, int(output_text_tokens or 0)),
-            "image_tokens": max(0, int(output_image_tokens or 0)),
-            "reasoning_tokens": 0,
-        },
-    }
-
-
-def image_usage(
-    input_text_tokens: int = 0,
-    input_image_tokens: int = 0,
-    output_tokens: int = 0,
-) -> dict[str, Any]:
-    return token_usage(
-        input_text_tokens=input_text_tokens,
-        input_image_tokens=input_image_tokens,
-        output_image_tokens=output_tokens,
-    )
-
-
-def chat_usage_from_image_usage(usage: dict[str, Any]) -> dict[str, Any]:
-    input_tokens = int(usage.get("input_tokens") or 0)
-    output_tokens = int(usage.get("output_tokens") or 0)
-    input_details = usage.get("input_tokens_details") if isinstance(usage.get("input_tokens_details"), dict) else {}
-    output_details = usage.get("output_tokens_details") if isinstance(usage.get("output_tokens_details"), dict) else {}
-    return {
-        "prompt_tokens": input_tokens,
-        "completion_tokens": output_tokens,
-        "total_tokens": input_tokens + output_tokens,
-        "prompt_tokens_details": {
-            "text_tokens": int(input_details.get("text_tokens") or 0),
-            "image_tokens": int(input_details.get("image_tokens") or 0),
-            "cached_tokens": int(input_details.get("cached_tokens") or 0),
-        },
-        "completion_tokens_details": {
-            "text_tokens": int(output_details.get("text_tokens") or 0),
-            "image_tokens": int(output_details.get("image_tokens") or 0),
-            "reasoning_tokens": int(output_details.get("reasoning_tokens") or 0),
-        },
-    }
+from __future__ import annotations
+
+import base64
+import math
+import re
+from io import BytesIO
+from typing import Any
+
+from PIL import Image
+
+DEFAULT_IMAGE_SIZE = (1024, 1024)
+IMAGE_INPUT_TOKEN_MODEL = "gpt-5.4-mini"
+
+PATCH_SIZE = 32
+TILE_SIZE = 512
+TILE_HIGH_SHORT_SIDE = 768
+
+PATCH_1536_MODELS = (
+    "gpt-5.4-mini",
+    "gpt-5.4-nano",
+    "gpt-5-mini",
+    "gpt-5-nano",
+    "gpt-5.2",
+    "gpt-5.3-codex",
+    "gpt-5-codex-mini",
+    "gpt-5.1-codex-mini",
+    "gpt-5.2-codex",
+    "gpt-5.2-chat-latest",
+    "o4-mini",
+    "gpt-4.1-mini",
+    "gpt-4.1-nano",
+)
+
+PATCH_MULTIPLIERS = {
+    "gpt-5.4-mini": 1.62,
+    "gpt-5.4-nano": 2.46,
+    "gpt-5-mini": 1.62,
+    "gpt-5-nano": 2.46,
+    "gpt-4.1-mini": 1.62,
+    "gpt-4.1-nano": 2.46,
+    "o4-mini": 1.72,
+}
+
+
+def _model_name(model: str) -> str:
+    return str(model or "").strip().lower()
+
+
+def image_size_from_bytes(data: bytes) -> tuple[int, int] | None:
+    if not data:
+        return None
+    try:
+        with Image.open(BytesIO(data)) as image:
+            width, height = image.size
+    except Exception:
+        return None
+    if width <= 0 or height <= 0:
+        return None
+    return int(width), int(height)
+
+
+def _decode_data_url(value: str) -> bytes:
+    text = str(value or "").strip()
+    payload = text.split(",", 1)[1] if text.startswith("data:") and "," in text else text
+    return base64.b64decode(payload)
+
+
+def image_size_from_data_url(value: str) -> tuple[int, int] | None:
+    try:
+        return image_size_from_bytes(_decode_data_url(value))
+    except Exception:
+        return None
+
+
+def parse_image_size(size: object, default: tuple[int, int] = DEFAULT_IMAGE_SIZE) -> tuple[int, int]:
+    if isinstance(size, (tuple, list)) and len(size) >= 2:
+        try:
+            width = int(size[0])
+            height = int(size[1])
+            if width > 0 and height > 0:
+                return width, height
+        except (TypeError, ValueError):
+            pass
+    match = re.search(r"(\d{2,5})\D+(\d{2,5})", str(size or ""))
+    if not match:
+        return default
+    width, height = int(match.group(1)), int(match.group(2))
+    return (width, height) if width > 0 and height > 0 else default
+
+
+def _patch_count(width: float, height: float) -> int:
+    return math.ceil(width / PATCH_SIZE) * math.ceil(height / PATCH_SIZE)
+
+
+def _patch_multiplier(model: str) -> float:
+    name = _model_name(model)
+    for prefix, multiplier in PATCH_MULTIPLIERS.items():
+        if name.startswith(prefix):
+            return multiplier
+    return 1.0
+
+
+def _patch_limits(model: str, detail: str) -> tuple[int, int] | None:
+    name = _model_name(model)
+    if any(name.startswith(prefix) for prefix in PATCH_1536_MODELS):
+        return 1536, 2048
+    if name.startswith("gpt-5.5"):
+        return (10000, 6000) if detail in {"auto", "original"} else (2500, 2048)
+    if name.startswith("gpt-5.4"):
+        return (10000, 6000) if detail == "original" else (2500, 2048)
+    return None
+
+
+def _patch_tokens(width: int, height: int, model: str, detail: str) -> int:
+    multiplier = _patch_multiplier(model)
+    if detail == "low":
+        return math.ceil(256 * multiplier)
+
+    limits = _patch_limits(model, detail)
+    if limits is None:
+        return 0
+    patch_budget, max_dimension = limits
+    scale = min(1.0, max_dimension / max(width, height))
+    resized_width = width * scale
+    resized_height = height * scale
+
+    if _patch_count(resized_width, resized_height) > patch_budget:
+        shrink_factor = math.sqrt((PATCH_SIZE * PATCH_SIZE * patch_budget) / (resized_width * resized_height))
+        width_units = resized_width * shrink_factor / PATCH_SIZE
+        height_units = resized_height * shrink_factor / PATCH_SIZE
+        adjusted_shrink_factor = shrink_factor * min(
+            math.floor(width_units) / width_units if width_units else 1,
+            math.floor(height_units) / height_units if height_units else 1,
+        )
+        resized_width *= adjusted_shrink_factor
+        resized_height *= adjusted_shrink_factor
+
+    tokens = min(_patch_count(max(1, resized_width), max(1, resized_height)), patch_budget)
+    return math.ceil(tokens * multiplier)
+
+
+def _tile_rates(model: str) -> tuple[int, int]:
+    name = _model_name(model)
+    if name in {"gpt-5", "gpt-5-chat-latest"}:
+        return 70, 140
+    if name.startswith("gpt-4o-mini"):
+        return 2833, 5667
+    if name.startswith(("o1", "o1-pro", "o3")):
+        return 75, 150
+    if name.startswith("computer-use-preview"):
+        return 65, 129
+    return 85, 170
+
+
+def _tile_tokens(width: int, height: int, model: str, detail: str) -> int:
+    base_tokens, tile_tokens = _tile_rates(model)
+    if detail == "low":
+        return base_tokens
+
+    scale = min(1.0, 2048 / max(width, height))
+    resized_width = width * scale
+    resized_height = height * scale
+    short_side = min(resized_width, resized_height)
+    if short_side > 0:
+        scale = TILE_HIGH_SHORT_SIDE / short_side
+        resized_width *= scale
+        resized_height *= scale
+
+    tiles = math.ceil(resized_width / TILE_SIZE) * math.ceil(resized_height / TILE_SIZE)
+    return base_tokens + tiles * tile_tokens
+
+
+def count_image_input_tokens(
+    width: int,
+    height: int,
+    model: str,
+    detail: str = "auto",
+    input_fidelity: str = "low",
+) -> int:
+    if width <= 0 or height <= 0:
+        return 0
+    detail = str(detail or "auto").strip().lower() or "auto"
+    return _patch_tokens(width, height, IMAGE_INPUT_TOKEN_MODEL, detail)
+
+
+def _part_size(part: dict[str, Any]) -> tuple[int, int] | None:
+    try:
+        width = int(part.get("width") or 0)
+        height = int(part.get("height") or 0)
+    except (TypeError, ValueError):
+        width = height = 0
+    if width > 0 and height > 0:
+        return width, height
+
+    data = part.get("data")
+    if isinstance(data, (bytes, bytearray)):
+        return image_size_from_bytes(bytes(data))
+
+    image_url = part.get("image_url")
+    if isinstance(image_url, dict):
+        image_url = image_url.get("url") or image_url.get("image_url")
+    if isinstance(image_url, str) and image_url.startswith("data:"):
+        return image_size_from_data_url(image_url)
+
+    source = part.get("source")
+    if isinstance(source, dict) and str(source.get("type") or "") == "base64":
+        try:
+            return image_size_from_bytes(base64.b64decode(str(source.get("data") or "")))
+        except Exception:
+            return None
+    return None
+
+
+def count_image_content_tokens(content: object, model: str, default_detail: str = "auto") -> int:
+    if not isinstance(content, list):
+        return 0
+    total = 0
+    for part in content:
+        if not isinstance(part, dict):
+            continue
+        part_type = str(part.get("type") or "").strip()
+        if part_type not in {"image", "image_url", "input_image"} and not part.get("source"):
+            continue
+        size = _part_size(part)
+        if not size:
+            continue
+        total += count_image_input_tokens(
+            size[0],
+            size[1],
+            model,
+            str(part.get("detail") or default_detail or "auto"),
+            str(part.get("input_fidelity") or part.get("inputFidelity") or "low"),
+        )
+    return total
+
+
+def count_image_inputs_tokens(images: object, model: str, default_detail: str = "auto") -> int:
+    if not images:
+        return 0
+    total = 0
+    entries = images if isinstance(images, list) else [images]
+    for image in entries:
+        data = image[0] if isinstance(image, tuple) and image else image
+        if not isinstance(data, (bytes, bytearray)):
+            continue
+        size = image_size_from_bytes(bytes(data))
+        if size:
+            total += count_image_input_tokens(size[0], size[1], model, default_detail)
+    return total
+
+
+def count_generated_image_tokens(width: int, height: int, quality: str = "auto") -> int:
+    patches = _patch_count(width, height)
+    quality = str(quality or "auto").strip().lower()
+    if quality == "low":
+        return math.ceil(patches * 17 / 64)
+    if quality in {"high", "hd"}:
+        return math.ceil(patches * 65 / 16)
+    return math.ceil(patches * 33 / 32)
+
+
+def count_image_output_tokens(size: object = None, quality: str = "auto", count: int = 1) -> int:
+    width, height = parse_image_size(size)
+    return max(0, int(count or 0)) * count_generated_image_tokens(width, height, quality)
+
+
+def count_image_output_items_tokens(
+    items: object,
+    size: object = None,
+    quality: str = "auto",
+) -> int:
+    if not isinstance(items, list) or not items:
+        return 0
+    fallback_size = parse_image_size(size)
+    total = 0
+    for item in items:
+        image_size = None
+        if isinstance(item, dict):
+            b64_json = str(item.get("b64_json") or "").strip()
+            if b64_json:
+                try:
+                    image_size = image_size_from_bytes(base64.b64decode(b64_json))
+                except Exception:
+                    image_size = None
+        width, height = image_size or fallback_size
+        total += count_generated_image_tokens(width, height, quality)
+    return total
+
+
+def token_usage(
+    input_text_tokens: int = 0,
+    input_image_tokens: int = 0,
+    output_text_tokens: int = 0,
+    output_image_tokens: int = 0,
+) -> dict[str, Any]:
+    input_tokens = max(0, int(input_text_tokens or 0)) + max(0, int(input_image_tokens or 0))
+    output_tokens = max(0, int(output_text_tokens or 0)) + max(0, int(output_image_tokens or 0))
+    return {
+        "input_tokens": input_tokens,
+        "output_tokens": output_tokens,
+        "total_tokens": input_tokens + output_tokens,
+        "input_tokens_details": {
+            "text_tokens": max(0, int(input_text_tokens or 0)),
+            "image_tokens": max(0, int(input_image_tokens or 0)),
+            "cached_tokens": 0,
+        },
+        "output_tokens_details": {
+            "text_tokens": max(0, int(output_text_tokens or 0)),
+            "image_tokens": max(0, int(output_image_tokens or 0)),
+            "reasoning_tokens": 0,
+        },
+    }
+
+
+def image_usage(
+    input_text_tokens: int = 0,
+    input_image_tokens: int = 0,
+    output_tokens: int = 0,
+) -> dict[str, Any]:
+    return token_usage(
+        input_text_tokens=input_text_tokens,
+        input_image_tokens=input_image_tokens,
+        output_image_tokens=output_tokens,
+    )
+
+
+def chat_usage_from_image_usage(usage: dict[str, Any]) -> dict[str, Any]:
+    input_tokens = int(usage.get("input_tokens") or 0)
+    output_tokens = int(usage.get("output_tokens") or 0)
+    input_details = usage.get("input_tokens_details") if isinstance(usage.get("input_tokens_details"), dict) else {}
+    output_details = usage.get("output_tokens_details") if isinstance(usage.get("output_tokens_details"), dict) else {}
+    return {
+        "prompt_tokens": input_tokens,
+        "completion_tokens": output_tokens,
+        "total_tokens": input_tokens + output_tokens,
+        "prompt_tokens_details": {
+            "text_tokens": int(input_details.get("text_tokens") or 0),
+            "image_tokens": int(input_details.get("image_tokens") or 0),
+            "cached_tokens": int(input_details.get("cached_tokens") or 0),
+        },
+        "completion_tokens_details": {
+            "text_tokens": int(output_details.get("text_tokens") or 0),
+            "image_tokens": int(output_details.get("image_tokens") or 0),
+            "reasoning_tokens": int(output_details.get("reasoning_tokens") or 0),
+        },
+    }