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.event_stream_service import get_default_event_bus
from backend.services.generation_service import GenerationService from backend.services.generation_service import GenerationService
from backend.services.image_service import ImageService 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.model_provider_service import ModelProviderService
from backend.services.queue_service import QueueService from backend.services.queue_service import QueueService
from backend.services.workflow_service import WorkflowService from backend.services.workflow_service import WorkflowService
@ -211,6 +212,8 @@ def _create_generation_service() -> GenerationService:
audit_service = AuditService(database) audit_service = AuditService(database)
workflow_repository = WorkflowRepository(database) workflow_repository = WorkflowRepository(database)
event_bus = get_default_event_bus() event_bus = get_default_event_bus()
model_provider_service = ModelProviderService(ModelProviderRepository(database))
model_provider_runtime = ModelProviderRuntime(model_provider_service)
return GenerationService( return GenerationService(
workflow_service=WorkflowService( workflow_service=WorkflowService(
workflow_repository=workflow_repository, workflow_repository=workflow_repository,
@ -228,6 +231,7 @@ def _create_generation_service() -> GenerationService:
workflow_repository=workflow_repository, workflow_repository=workflow_repository,
audit_service=audit_service, 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, 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 base64
import re import re
import urllib.request
from dataclasses import dataclass from dataclasses import dataclass
from pathlib import Path from pathlib import Path
from typing import Any from typing import Any, Callable
from backend.dto.job_dto import GenerationTask from backend.dto.job_dto import GenerationTask
from backend.dto.workflow_dto import WorkflowNode from backend.dto.workflow_dto import WorkflowNode
from core.storage import VfsStorage from core.storage import VfsStorage
from engines.image_provider import ImageGenerationRequest, ImageProvider, ImageProviderError
ONE_PIXEL_PNG = base64.b64decode( ONE_PIXEL_PNG = base64.b64decode(
@ -31,14 +33,52 @@ class MockGeneratedAsset:
class SingleFlowEngine: 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.storage = storage or VfsStorage()
self.image_provider_factory = image_provider_factory
def generate(self, node: WorkflowNode, task: GenerationTask, request: dict[str, Any]) -> list[MockGeneratedAsset]: def generate(self, node: WorkflowNode, task: GenerationTask, request: dict[str, Any]) -> list[MockGeneratedAsset]:
count = _bounded_count(request.get("count", 1)) count = _bounded_count(request.get("count", 1))
prompt = _compose_prompt(node.prompt, request.get("prompt_patch")) prompt = _compose_prompt(node.prompt, request.get("prompt_patch"))
model_route = str(request.get("model_route") or node.model_route or "image_low") 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")) 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] = [] assets: list[MockGeneratedAsset] = []
task_stem = _safe_file_stem(task.task_id) task_stem = _safe_file_stem(task.task_id)
for index in range(count): for index in range(count):
@ -60,15 +100,83 @@ class SingleFlowEngine:
"engine": "single_flow_mock", "engine": "single_flow_mock",
"quality": request.get("quality", "low"), "quality": request.get("quality", "low"),
"mock": True, "mock": True,
**({"provider_error": provider_error} if provider_error else {}),
}, },
) )
) )
return assets 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 = self.storage.resolve_uri(uri)
Path(path).parent.mkdir(parents=True, exist_ok=True) 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: 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: def _safe_file_stem(value: str) -> str:
stem = re.sub(r"[^A-Za-z0-9_-]+", "_", str(value or "").strip()).strip("_") stem = re.sub(r"[^A-Za-z0-9_-]+", "_", str(value or "").strip()).strip("_")
return stem or "task" 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.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository from database.repositories.workflow_repository import WorkflowRepository
from engines.single_flow import SingleFlowEngine from engines.single_flow import SingleFlowEngine
from engines.image_provider import GeneratedImagePayload, ImageGenerationResult
class SingleFlowGenerationTests(unittest.TestCase): 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.assertFalse(any(":\\" in str(value) or str(self.root) in str(value) for value in serialized.values()))
self.assertNotIn("local_path", asset.metadata) 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): def test_queue_service_rejects_invalid_task_transition(self):
task = self.queue_service.create_task({"status": "succeeded"}, self.ctx) task = self.queue_service.create_task({"status": "succeeded"}, self.ctx)