astrbot_plugin_imagestudio/engines/single_flow.py

216 行
7.9 KiB
Python

"""Single image workflow mock engine."""
from __future__ import annotations
import base64
import re
import urllib.request
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Callable
from backend.dto.job_dto import GenerationTask
from backend.dto.workflow_dto import WorkflowNode
from core.storage import VfsStorage
from engines.image_provider import ImageGenerationRequest, ImageProvider, ImageProviderError
ONE_PIXEL_PNG = base64.b64decode(
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII="
)
@dataclass(frozen=True)
class MockGeneratedAsset:
image_uri: str
thumbnail_uri: str
positive_prompt: str
model_route: str | None
width: int
height: int
seed: int
metadata: dict[str, Any]
class SingleFlowEngine:
def __init__(
self,
storage: VfsStorage | None = None,
image_provider_factory: Callable[[dict[str, Any]], ImageProvider | None] | None = None,
):
self.storage = storage or VfsStorage()
self.image_provider_factory = image_provider_factory
def generate(self, node: WorkflowNode, task: GenerationTask, request: dict[str, Any]) -> list[MockGeneratedAsset]:
count = _bounded_count(request.get("count", 1))
prompt = _compose_prompt(node.prompt, request.get("prompt_patch"))
model_route = str(request.get("model_route") or node.model_route or "image_low")
width, height = _dimensions(str(request.get("aspect_ratio") or "1:1"))
provider = self._image_provider(request)
if provider is not None:
try:
return self._generate_with_provider(provider, task, request, prompt, model_route, width, height, count)
except ImageProviderError as exc:
return self._generate_mock(
task,
request,
prompt,
model_route,
width,
height,
count,
provider_error={
"provider_id": exc.provider_id,
"error_type": exc.error_type,
"status_code": exc.status_code,
},
)
return self._generate_mock(task, request, prompt, model_route, width, height, count)
def _generate_mock(
self,
task: GenerationTask,
request: dict[str, Any],
prompt: str,
model_route: str,
width: int,
height: int,
count: int,
*,
provider_error: dict[str, Any] | None = None,
) -> list[MockGeneratedAsset]:
assets: list[MockGeneratedAsset] = []
task_stem = _safe_file_stem(task.task_id)
for index in range(count):
seed = int(request.get("seed") or 1000 + index)
image_uri = f"storage://images/single/{task_stem}_{index + 1}.png"
thumbnail_uri = f"storage://thumbnails/single/{task_stem}_{index + 1}.png"
self._write_png(image_uri)
self._write_png(thumbnail_uri)
assets.append(
MockGeneratedAsset(
image_uri=image_uri,
thumbnail_uri=thumbnail_uri,
positive_prompt=prompt,
model_route=model_route,
width=width,
height=height,
seed=seed,
metadata={
"engine": "single_flow_mock",
"quality": request.get("quality", "low"),
"mock": True,
**({"provider_error": provider_error} if provider_error else {}),
},
)
)
return assets
def _generate_with_provider(
self,
provider: ImageProvider,
task: GenerationTask,
request: dict[str, Any],
prompt: str,
model_route: str,
width: int,
height: int,
count: int,
) -> list[MockGeneratedAsset]:
route = dict(request.get("resolved_model_route") or {})
result = provider.generate_image(
ImageGenerationRequest(
prompt=prompt,
model=str(route.get("model_id") or model_route),
size=f"{width}x{height}",
count=count,
input_images=tuple(str(item) for item in request.get("input_images") or request.get("image") or []),
metadata={"task_id": task.task_id, "model_route": model_route},
)
)
assets: list[MockGeneratedAsset] = []
task_stem = _safe_file_stem(task.task_id)
for index, image in enumerate(result.images):
if not image.has_image_data:
continue
image_bytes = _image_bytes(image.b64_json, image.url)
image_uri = f"storage://images/single/{task_stem}_{index + 1}.png"
thumbnail_uri = f"storage://thumbnails/single/{task_stem}_{index + 1}.png"
self._write_png(image_uri, image_bytes)
self._write_png(thumbnail_uri, image_bytes)
assets.append(
MockGeneratedAsset(
image_uri=image_uri,
thumbnail_uri=thumbnail_uri,
positive_prompt=image.revised_prompt or prompt,
model_route=model_route,
width=width,
height=height,
seed=int(request.get("seed") or 1000 + index),
metadata={
"engine": "single_flow_provider",
"mock": False,
"provider_id": result.provider_id,
"provider_model": result.model,
"usage": result.usage,
"source_url": image.url,
},
)
)
if not assets:
raise ImageProviderError(
"image provider returned no usable image payloads",
provider_id=result.provider_id,
error_type="invalid_response",
)
return assets
def _write_png(self, uri: str, content: bytes = ONE_PIXEL_PNG) -> None:
path = self.storage.resolve_uri(uri)
Path(path).parent.mkdir(parents=True, exist_ok=True)
Path(path).write_bytes(content)
def _image_provider(self, request: dict[str, Any]) -> ImageProvider | None:
if not self.image_provider_factory:
return None
route = request.get("resolved_model_route") if isinstance(request.get("resolved_model_route"), dict) else {}
if route.get("status") != "resolved":
return None
return self.image_provider_factory(route)
def _bounded_count(value: Any) -> int:
try:
count = int(value)
except (TypeError, ValueError):
count = 1
return min(max(count, 1), 8)
def _compose_prompt(base_prompt: str | None, prompt_patch: Any) -> str:
parts = [part.strip() for part in [base_prompt, str(prompt_patch or "")] if part and str(part).strip()]
return ", ".join(parts) if parts else "single image mock generation"
def _dimensions(aspect_ratio: str) -> tuple[int, int]:
if aspect_ratio == "3:4":
return 768, 1024
if aspect_ratio == "4:3":
return 1024, 768
if aspect_ratio == "16:9":
return 1280, 720
return 1024, 1024
def _safe_file_stem(value: str) -> str:
stem = re.sub(r"[^A-Za-z0-9_-]+", "_", str(value or "").strip()).strip("_")
return stem or "task"
def _image_bytes(b64_json: str | None, url: str | None) -> bytes:
if b64_json:
return base64.b64decode(re.sub(r"\s+", "", b64_json))
if url:
with urllib.request.urlopen(url, timeout=120) as response:
return response.read()
raise ImageProviderError("image payload is empty", provider_id="unknown", error_type="invalid_response")