dsh-plugin-image-workbench 0.0.0-stage → 1.1.5

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

@@ -0,0 +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),
+        },
+    }

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

@@ -0,0 +1,110 @@
+import base64
+import binascii
+import json
+import logging
+import re
+from typing import Any
+
+
+class Logger:
+    _DATA_URL_RE = re.compile(r"data:image/[^;]+;base64,[A-Za-z0-9+/=]+")
+    _JSON_B64_RE = re.compile(r'("b64_json"\s*:\s*")([A-Za-z0-9+/=]+)(")')
+
+    def __init__(self, name: str = "chatgpt2api") -> None:
+        self._logger = logging.getLogger(name)
+        if not self._logger.handlers:
+            handler = logging.StreamHandler()
+            handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
+            self._logger.addHandler(handler)
+        self._logger.setLevel(logging.DEBUG)
+        self._logger.propagate = False
+
+    def _enabled(self, level: str) -> bool:
+        try:
+            from services.config import config
+            levels = set(config.log_levels)
+        except Exception:
+            levels = set()
+        return level in (levels or {"info", "warning", "error"})
+
+    def _mask_string(self, value: str, keep: int = 10) -> str:
+        if len(value) <= keep:
+            return value
+        return value[:keep] + "..."
+
+    def _mask_base64(self, value: str) -> str:
+        if value.startswith("data:") and ";base64," in value:
+            header, _, data = value.partition(",")
+            return f"{header},{self._mask_string(data, 24)} (base64 len={len(data)})"
+        return f"{self._mask_string(value, 24)} (base64 len={len(value)})"
+
+    def _is_base64_string(self, value: str) -> bool:
+        if len(value) < 64 or len(value) % 4 != 0:
+            return False
+        if not any(char in value for char in "+/="):
+            return False
+        try:
+            base64.b64decode(value, validate=True)
+            return True
+        except (binascii.Error, ValueError):
+            return False
+
+    def _sanitize_string(self, value: str) -> str:
+        stripped = value.strip()
+        if stripped.startswith("data:") and ";base64," in stripped:
+            return self._mask_base64(stripped)
+        if self._is_base64_string(stripped):
+            return self._mask_base64(stripped)
+        sanitized = self._DATA_URL_RE.sub(lambda match: self._mask_base64(match.group(0)), value)
+        sanitized = self._JSON_B64_RE.sub(
+            lambda match: f'{match.group(1)}{self._mask_base64(match.group(2))}{match.group(3)}',
+            sanitized,
+        )
+        if sanitized != value:
+            return sanitized
+        return value
+
+    def _sanitize(self, value: Any) -> Any:
+        if isinstance(value, dict):
+            sanitized = {}
+            for key, item in value.items():
+                lowered_key = key.lower()
+                if isinstance(item, str) and ("token" in lowered_key or lowered_key == "dx"):
+                    sanitized[key] = self._mask_string(item)
+                elif isinstance(item, str) and ("base64" in lowered_key or lowered_key == "b64_json"):
+                    sanitized[key] = self._mask_base64(item)
+                else:
+                    sanitized[key] = self._sanitize(item)
+            return sanitized
+        if isinstance(value, list):
+            return [self._sanitize(item) for item in value]
+        if isinstance(value, tuple):
+            return tuple(self._sanitize(item) for item in value)
+        if isinstance(value, str):
+            return self._sanitize_string(value)
+        return value
+
+    def _message(self, value: Any) -> str:
+        sanitized = self._sanitize(value)
+        if isinstance(sanitized, str):
+            return sanitized
+        return json.dumps(sanitized, ensure_ascii=False, default=str)
+
+    def debug(self, message: Any) -> None:
+        if self._enabled("debug"):
+            self._logger.debug(self._message(message))
+
+    def info(self, message: Any) -> None:
+        if self._enabled("info"):
+            self._logger.info(self._message(message))
+
+    def warning(self, message: Any) -> None:
+        if self._enabled("warning"):
+            self._logger.warning(self._message(message))
+
+    def error(self, message: Any) -> None:
+        if self._enabled("error"):
+            self._logger.error(self._message(message))
+
+
+logger = Logger()

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

@@ -0,0 +1,19 @@
+"""PKCE (Proof Key for Code Exchange) 工具函数"""
+from __future__ import annotations
+
+import base64
+import hashlib
+import secrets
+
+
+def generate_pkce() -> tuple[str, str]:
+    """生成 PKCE code_verifier 与对应的 code_challenge（S256）。
+
+    Returns:
+        (code_verifier, code_challenge) 元组
+    """
+    code_verifier = base64.urlsafe_b64encode(secrets.token_bytes(64)).rstrip(b"=").decode("ascii")
+    code_challenge = base64.urlsafe_b64encode(
+        hashlib.sha256(code_verifier.encode("ascii")).digest()
+    ).rstrip(b"=").decode("ascii")
+    return code_verifier, code_challenge

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

@@ -0,0 +1,207 @@
+import hashlib
+import json
+import random
+import re
+import time
+from datetime import datetime, timedelta, timezone
+from html.parser import HTMLParser
+from typing import Any, Sequence
+
+import pybase64
+
+DEFAULT_POW_SCRIPT = "https://chatgpt.com/backend-api/sentinel/sdk.js"
+from utils.helper import new_uuid
+
+
+CORES = [8, 16, 24, 32]
+DOCUMENT_KEYS = ["__reactContainer$fzelfjyxej8", "_reactListening5dehydibo78", "location"]
+SCREEN_RESOLUTIONS = [[1920, 1080], [1440, 900], [2560, 1440], [3840, 2160]]
+
+
+class ScriptSrcParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__()
+        self.script_sources: list[str] = []
+        self.data_build = ""
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if tag != "script":
+            return
+        attrs_dict = dict(attrs)
+        src = attrs_dict.get("src")
+        if not src:
+            return
+        self.script_sources.append(src)
+        match = re.search(r"c/[^/]*/_", src)
+        if match:
+            self.data_build = match.group(0)
+
+
+def parse_pow_resources(html_content: str) -> tuple[list[str], str]:
+    parser = ScriptSrcParser()
+    parser.feed(html_content)
+    script_sources = parser.script_sources or [DEFAULT_POW_SCRIPT]
+    data_build = parser.data_build
+    if not data_build:
+        match = re.search(r'<html[^>]*data-build="([^"]*)"', html_content)
+        if match:
+            data_build = match.group(1)
+    return script_sources, data_build
+
+
+def _legacy_parse_time() -> str:
+    now = datetime.now(timezone(timedelta(hours=-5)))
+    return now.strftime("%a %b %d %Y %H:%M:%S") + " GMT-0500 (Eastern Standard Time)"
+
+
+def build_pow_config(
+    user_agent: str,
+    script_sources: Sequence[str] | None = None,
+    data_build: str = "",
+) -> list[Any]:
+    navigator_key = random.choice([
+        "registerProtocolHandler−function registerProtocolHandler() { [native code] }",
+        "storage−[object StorageManager]",
+        "locks−[object LockManager]",
+        "appCodeName−Mozilla",
+        "permissions−[object Permissions]",
+        "share−function share() { [native code] }",
+        "webdriver−false",
+        "managed−[object NavigatorManagedData]",
+        "canShare−function canShare() { [native code] }",
+        "vendor−Google Inc.",
+        "mediaDevices−[object MediaDevices]",
+        "vibrate−function vibrate() { [native code] }",
+        "storageBuckets−[object StorageBucketManager]",
+        "mediaCapabilities−[object MediaCapabilities]",
+        "cookieEnabled−true",
+        "virtualKeyboard−[object VirtualKeyboard]",
+        "product−Gecko",
+        "presentation−[object Presentation]",
+        "onLine−true",
+        "mimeTypes−[object MimeTypeArray]",
+        "credentials−[object CredentialsContainer]",
+        "serviceWorker−[object ServiceWorkerContainer]",
+        "keyboard−[object Keyboard]",
+        "gpu−[object GPU]",
+        "doNotTrack",
+        "serial−[object Serial]",
+        "pdfViewerEnabled−true",
+        "language−zh-CN",
+        "geolocation−[object Geolocation]",
+        "userAgentData−[object NavigatorUAData]",
+        "getUserMedia−function getUserMedia() { [native code] }",
+        "sendBeacon−function sendBeacon() { [native code] }",
+        "hardwareConcurrency−32",
+        "windowControlsOverlay−[object WindowControlsOverlay]",
+    ])
+    window_key = random.choice([
+        "0",
+        "window",
+        "self",
+        "document",
+        "name",
+        "location",
+        "customElements",
+        "history",
+        "navigation",
+        "innerWidth",
+        "innerHeight",
+        "scrollX",
+        "scrollY",
+        "visualViewport",
+        "screenX",
+        "screenY",
+        "outerWidth",
+        "outerHeight",
+        "devicePixelRatio",
+        "screen",
+        "chrome",
+        "navigator",
+        "onresize",
+        "performance",
+        "crypto",
+        "indexedDB",
+        "sessionStorage",
+        "localStorage",
+        "scheduler",
+        "alert",
+        "atob",
+        "btoa",
+        "fetch",
+        "matchMedia",
+        "postMessage",
+        "queueMicrotask",
+        "requestAnimationFrame",
+        "setInterval",
+        "setTimeout",
+        "caches",
+        "__NEXT_DATA__",
+        "__BUILD_MANIFEST",
+        "__NEXT_PRELOADREADY",
+    ])
+    script_source = random.choice(list(script_sources)) if script_sources else DEFAULT_POW_SCRIPT
+    return [
+        sum(random.choices(SCREEN_RESOLUTIONS, k=1)[0]),
+        _legacy_parse_time(),
+        4294705152,
+        1,
+        user_agent,
+        script_source,
+        data_build,
+        "en-US",
+        "en-US,es-US,en,es",
+        random.random(),
+        navigator_key,
+        random.choice(DOCUMENT_KEYS),
+        window_key,
+        time.perf_counter() * 1000,
+        new_uuid(),
+        "",
+        random.choice(CORES),
+        time.time() * 1000 - (time.perf_counter() * 1000),
+        0, 0, 0, 0, 0, 0,
+        0,  # 0 = edge/chrome, 1 = firefox
+    ]
+
+
+def _pow_generate(seed: str, difficulty: str, config: list[Any], limit: int = 500000) -> tuple[str, bool]:
+    target = bytes.fromhex(difficulty)
+    diff_len = len(difficulty) // 2
+    seed_bytes = seed.encode()
+    static_1 = (json.dumps(config[:3], separators=(",", ":"), ensure_ascii=False)[:-1] + ",").encode()
+    static_2 = ("," + json.dumps(config[4:9], separators=(",", ":"), ensure_ascii=False)[1:-1] + ",").encode()
+    static_3 = ("," + json.dumps(config[10:], separators=(",", ":"), ensure_ascii=False)[1:]).encode()
+    for i in range(limit):
+        final_json = static_1 + str(i).encode() + static_2 + str(i >> 1).encode() + static_3
+        encoded = pybase64.b64encode(final_json)
+        digest = hashlib.sha3_512(seed_bytes + encoded).digest()
+        if digest[:diff_len] <= target:
+            return encoded.decode(), True
+    fallback = "wQ8Lk5FbGpA2NcR9dShT6gYjU7VxZ4D" + pybase64.b64encode(f'"{seed}"'.encode()).decode()
+    return fallback, False
+
+
+def build_legacy_requirements_token(
+    user_agent: str,
+    script_sources: Sequence[str] | None = None,
+    data_build: str = "",
+) -> str:
+    config = build_pow_config(user_agent, script_sources=script_sources, data_build=data_build)
+    return "gAAAAAC" + pybase64.b64encode(
+        json.dumps(config, separators=(",", ":"), ensure_ascii=False).encode()
+    ).decode()
+
+
+def build_proof_token(
+    seed: str,
+    difficulty: str,
+    user_agent: str,
+    script_sources: Sequence[str] | None = None,
+    data_build: str = "",
+) -> str:
+    config = build_pow_config(user_agent, script_sources=script_sources, data_build=data_build)
+    answer, solved = _pow_generate(seed, difficulty, config)
+    if not solved:
+        raise RuntimeError(f"failed to solve proof token: difficulty={difficulty}")
+    return "gAAAAAB" + answer