"""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.generation_errors import provider_failure_attribution 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 negative_prompt: str | None 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 = _optional_text(request.get("expanded_prompt")) or _compose_prompt(node.prompt, request.get("prompt_patch")) negative_prompt = _optional_text(request.get("expanded_negative_prompt")) or _optional_text(node.negative_prompt) 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, negative_prompt, model_route, width, height, count, ) except ImageProviderError as exc: route = request.get("resolved_model_route") if isinstance(request.get("resolved_model_route"), dict) else {} return self._generate_mock( task, request, prompt, negative_prompt, model_route, width, height, count, provider_error=provider_failure_attribution(exc, route_context=route, fallback_used=True), ) return self._generate_mock(task, request, prompt, negative_prompt, model_route, width, height, count) def _generate_mock( self, task: GenerationTask, request: dict[str, Any], prompt: str, negative_prompt: str | None, 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, negative_prompt=negative_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, negative_prompt: str | None, 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, provider_id=result.provider_id) 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, negative_prompt=negative_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 _optional_text(value: Any) -> str | None: if value is None: return None text = str(value).strip() return text or None 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, *, provider_id: str = "unknown") -> bytes: if b64_json: return base64.b64decode(re.sub(r"\s+", "", b64_json)) if url: try: with urllib.request.urlopen(url, timeout=120) as response: return response.read() except Exception as exc: raise ImageProviderError( "image provider image URL could not be downloaded", provider_id=provider_id, error_type="network_error", details={"reason": str(exc)}, ) from exc raise ImageProviderError("image payload is empty", provider_id=provider_id, error_type="invalid_response")