S81 B站点真实生图执行器

这个提交存在于:
YokiiroBW 2026-07-06 02:08:07 +08:00
父节点 1934be3be7
当前提交 25a061c3a5
共有 5 个文件被更改,包括 293 次插入 和 5 次删除

查看文件

@ -10,6 +10,7 @@ from backend.routes.common import handle_request
from backend.services.event_stream_service import get_default_event_bus
from backend.services.generation_service import GenerationService
from backend.services.image_service import ImageService
from backend.services.model_provider_runtime import ModelProviderRuntime
from backend.services.model_provider_service import ModelProviderService
from backend.services.queue_service import QueueService
from backend.services.workflow_service import WorkflowService
@ -211,6 +212,8 @@ def _create_generation_service() -> GenerationService:
audit_service = AuditService(database)
workflow_repository = WorkflowRepository(database)
event_bus = get_default_event_bus()
model_provider_service = ModelProviderService(ModelProviderRepository(database))
model_provider_runtime = ModelProviderRuntime(model_provider_service)
return GenerationService(
workflow_service=WorkflowService(
workflow_repository=workflow_repository,
@ -228,6 +231,7 @@ def _create_generation_service() -> GenerationService:
workflow_repository=workflow_repository,
audit_service=audit_service,
),
model_provider_service=ModelProviderService(ModelProviderRepository(database)),
single_flow_engine=SingleFlowEngine(image_provider_factory=model_provider_runtime.image_provider_for_route),
model_provider_service=model_provider_service,
event_bus=event_bus,
)

查看文件

@ -0,0 +1,50 @@
"""Runtime helpers for building provider clients from persisted routes."""
from __future__ import annotations
from typing import Any
from backend.services.model_provider_service import ModelProviderService
from core.secret_service import SecretStore, resolve_secret_value
from engines.image_provider import ImageProvider, ImageProviderConfig, OpenAIImageProvider
class ModelProviderRuntime:
def __init__(
self,
model_provider_service: ModelProviderService,
*,
secret_store: SecretStore | None = None,
):
self.model_provider_service = model_provider_service
self.secret_store = secret_store
def image_provider_for_route(self, route_context: dict[str, Any]) -> ImageProvider | None:
route_name = str(route_context.get("route_name") or "").strip()
if not route_name:
return None
resolved = self.model_provider_service.resolve_route(route_name, modality="image_generation")
if not resolved:
return None
provider = resolved.get("provider") or {}
if str(provider.get("provider_type") or "openai_compatible") != "openai_compatible":
return None
secret = resolve_secret_value(
env_var=provider.get("api_key_env_var"),
secret_ref=provider.get("api_key_secret_ref"),
secret_store=self.secret_store,
)
if not secret.value:
return None
return OpenAIImageProvider(
ImageProviderConfig(
provider_id=str(resolved["provider_id"]),
base_url=str(provider.get("base_url") or ""),
api_key=secret.value,
image_model=str(resolved["model_id"]),
image_endpoint=str(provider.get("image_endpoint") or "/v1/images/generations"),
provider_type=str(provider.get("provider_type") or "openai_compatible"),
timeout_seconds=int(provider.get("timeout_seconds") or 180),
extra_headers=dict(provider.get("extra_headers") or {}),
)
)

查看文件

@ -4,13 +4,15 @@ from __future__ import annotations
import base64
import re
import urllib.request
from dataclasses import dataclass
from pathlib import Path
from typing import Any
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(
@ -31,14 +33,52 @@ class MockGeneratedAsset:
class SingleFlowEngine:
def __init__(self, storage: VfsStorage | None = None):
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):
@ -60,15 +100,83 @@ class SingleFlowEngine:
"engine": "single_flow_mock",
"quality": request.get("quality", "low"),
"mock": True,
**({"provider_error": provider_error} if provider_error else {}),
},
)
)
return assets
def _write_png(self, uri: str) -> None:
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(ONE_PIXEL_PNG)
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:
@ -97,3 +205,12 @@ def _dimensions(aspect_ratio: str) -> tuple[int, int]:
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")

查看文件

@ -0,0 +1,43 @@
from __future__ import annotations
import os
import tempfile
import unittest
from pathlib import Path
from backend.services.model_provider_runtime import ModelProviderRuntime
from backend.services.model_provider_service import ModelProviderService
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.model_provider_repository import ModelProviderRepository
class ModelProviderRuntimeTests(unittest.TestCase):
def test_runtime_builds_openai_provider_from_env_secret(self):
with tempfile.TemporaryDirectory() as tmp:
database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(Path(tmp) / "imagestudio.db"))))
database.initialize()
service = ModelProviderService(ModelProviderRepository(database))
service.upsert_provider(
{
"provider_id": "site_b",
"base_url": "https://botcf.com",
"image_endpoint": "/v1/images/generations",
"api_key_env_var": "IMAGESTUDIO_TEST_SITE_B",
"timeout_seconds": 180,
}
)
service.upsert_route({"route_name": "image_high", "provider_id": "site_b", "model_id": "image2"})
os.environ["IMAGESTUDIO_TEST_SITE_B"] = "secret-value"
try:
provider = ModelProviderRuntime(service).image_provider_for_route({"route_name": "image_high"})
finally:
os.environ.pop("IMAGESTUDIO_TEST_SITE_B", None)
self.assertIsNotNone(provider)
self.assertEqual(provider.config.provider_id, "site_b")
self.assertEqual(provider.config.image_model, "image2")
self.assertEqual(provider.config.api_key, "secret-value")
if __name__ == "__main__":
unittest.main()

查看文件

@ -26,6 +26,7 @@ from database.repositories.model_provider_repository import ModelProviderReposit
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
from engines.single_flow import SingleFlowEngine
from engines.image_provider import GeneratedImagePayload, ImageGenerationResult
class SingleFlowGenerationTests(unittest.TestCase):
@ -251,6 +252,79 @@ storage:
self.assertFalse(any(":\\" in str(value) or str(self.root) in str(value) for value in serialized.values()))
self.assertNotIn("local_path", asset.metadata)
def test_single_flow_engine_can_persist_provider_payloads(self):
class FakeProvider:
provider_id = "site_b"
def generate_image(self, request):
return ImageGenerationResult(
provider_id=self.provider_id,
model=request.model or "image2",
images=[
GeneratedImagePayload(
b64_json="iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=",
revised_prompt=request.prompt,
)
],
usage={"total_tokens": 12},
)
engine = SingleFlowEngine(
VfsStorage(self.config_service),
image_provider_factory=lambda route: FakeProvider(),
)
node = WorkflowNode(
node_id="node_001",
workflow_id="workflow_001",
node_key="single",
title="Single",
description=None,
step_name=None,
node_type="single_image",
status="running",
branch_name="main",
prompt="portrait",
negative_prompt=None,
model_route="image_high",
selected_image_id=None,
sort_order=1,
metadata={},
created_at="2026-01-01T00:00:00Z",
updated_at="2026-01-01T00:00:00Z",
)
task = GenerationTask(
task_id="task_provider",
profile_id="profile_001",
workflow_id="workflow_001",
node_id="node_001",
task_type="generate",
status="running",
model_route="image_high",
progress=20,
idempotency_key=None,
request={},
result={},
error_message=None,
metadata={},
created_at="2026-01-01T00:00:00Z",
updated_at="2026-01-01T00:00:00Z",
)
assets = engine.generate(
node,
task,
{
"model_route": "image_high",
"resolved_model_route": {"status": "resolved", "route_name": "image_high", "model_id": "image2"},
},
)
self.assertEqual(len(assets), 1)
self.assertFalse(assets[0].metadata["mock"])
self.assertEqual(assets[0].metadata["provider_id"], "site_b")
self.assertEqual(assets[0].metadata["usage"]["total_tokens"], 12)
self.assertTrue(VfsStorage(self.config_service).ensure_file(assets[0].image_uri).exists())
def test_queue_service_rejects_invalid_task_transition(self):
task = self.queue_service.create_task({"status": "succeeded"}, self.ctx)