astrbot_plugin_imagestudio/backend/services/service_registry.py

161 行
8.7 KiB
Python

"""Composition root for request-scoped services.
Route modules used to each carry their own ``_create_*_service()`` factory --
35 of them across 20 modules. Because the wiring was duplicated rather than
shared, the factories drifted: four of the seven ``WorkflowService`` builders
omitted ``event_bus`` entirely, so whether a workflow mutation published an
event depended on which route you happened to enter through. That is how
``branch_routes`` stopped pushing branch events and ``node_material_routes``
stopped publishing material-binding events -- not a bug anyone wrote, a bug
that grew out of copy-paste assembly.
Assembling in one place makes the dependency set a single decision. Adding a
collaborator here reaches every route at once, which is exactly the property
the per-module factories lacked.
"""
from __future__ import annotations
from backend.services.event_stream_service import get_default_event_bus
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from database.db_helper import Database, load_database_settings
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
def create_database() -> Database:
"""Build a ``Database`` from the active configuration."""
return Database(load_database_settings())
def create_workflow_service(database: Database | None = None) -> WorkflowService:
"""Assemble ``WorkflowService`` with its full collaborator set.
``event_bus`` is not optional in practice: without it every
``publish(...)`` call inside the service becomes a silent no-op and the
frontend's event stream simply never sees the change.
"""
resolved = database or create_database()
return WorkflowService(
workflow_repository=WorkflowRepository(resolved),
profile_repository=ProfileRepository(resolved),
audit_service=AuditService(resolved),
event_bus=get_default_event_bus(),
)
# ---------------------------------------------------------------------------
# Generation service assembly
#
# This used to live in ``backend/routes/node_routes.py``, which forced
# ``workflow_round_worker_runtime`` -- a background worker with no HTTP
# involvement whatsoever -- to import from the route layer just to start up.
# That was the repository's only service -> route dependency, and it made the
# worker transitively drag in every route module's imports. Assembly is
# composition-root work, so it lives here.
# ---------------------------------------------------------------------------
from backend.services.cost_guard_service import CostGuardService
from backend.services.cost_service import CostService
from backend.services.generation_service import GenerationService
from backend.services.image_service import ImageService
from backend.services.material_catalog_resolver import MaterialCatalogResolver
from backend.services.model_provider_bootstrap import sync_generation_provider_from_config
from backend.services.model_provider_runtime import ModelProviderRuntime
from backend.services.model_provider_service import ModelProviderService
from backend.services.prompt_expansion_service import PromptExpansionService
from backend.services.prompt_governance_service import (
GenerationRouteService,
ImageModerationService,
PromptModerationService,
PromptSemanticNormalizer,
PromptTranslationService,
)
from backend.services.queue_service import QueueService
from backend.services.workflow_material_snapshot_service import WorkflowMaterialSnapshotService
from core.astrbot_provider_bridge import astrbot_structured_text_callable
from database.db_helper import load_config_payload
from database.repositories.advanced_material_repository import AdvancedMaterialRepository
from database.repositories.image_repository import ImageRepository
from database.repositories.job_repository import JobRepository
from database.repositories.material_repository import MaterialRepository
from database.repositories.model_provider_repository import ModelProviderRepository
from engines.single_flow import SingleFlowEngine
def create_generation_service() -> GenerationService:
"""Public runtime factory shared by HTTP routes and background workers."""
database = Database(load_database_settings())
audit_service = AuditService(database)
workflow_repository = WorkflowRepository(database)
material_repository = MaterialRepository(database)
material_catalog = MaterialCatalogResolver(
material_repository,
AdvancedMaterialRepository(database),
)
event_bus = get_default_event_bus()
model_provider_service = ModelProviderService(ModelProviderRepository(database))
model_provider_runtime = ModelProviderRuntime(model_provider_service)
config_payload = load_config_payload()
sync_generation_provider_from_config(model_provider_service, config_payload)
generation_config = config_payload.get("generation") if isinstance(config_payload.get("generation"), dict) else {}
model_assignments = config_payload.get("model_assignments") if isinstance(config_payload.get("model_assignments"), dict) else {}
governance_config = config_payload.get("prompt_governance") if isinstance(config_payload.get("prompt_governance"), dict) else {}
translation_config = governance_config.get("translation") if isinstance(governance_config.get("translation"), dict) else {}
moderation_config = governance_config.get("moderation") if isinstance(governance_config.get("moderation"), dict) else {}
routing_config = governance_config.get("routing") if isinstance(governance_config.get("routing"), dict) else {}
image_moderation_config = governance_config.get("image_moderation") if isinstance(governance_config.get("image_moderation"), dict) else {}
translation_route = str(translation_config.get("model_route") or model_assignments.get("prompt_planning") or "").strip()
moderation_route = str(moderation_config.get("model_route") or model_assignments.get("cross_review_primary") or "").strip()
translation_callable = (model_provider_runtime.structured_text_callable(translation_route) or astrbot_structured_text_callable(translation_route)) if translation_route else None
moderation_callable = (model_provider_runtime.structured_text_callable(moderation_route) or astrbot_structured_text_callable(moderation_route)) if moderation_route else None
single_flow_engine = SingleFlowEngine(
image_provider_factory=model_provider_runtime.image_provider_for_route,
allow_mock_fallback=False,
)
image_moderation_route = str(image_moderation_config.get("model_route") or "").strip()
image_moderation_callable = model_provider_runtime.structured_vision_callable(
image_moderation_route,
storage=single_flow_engine.storage,
) if image_moderation_route else None
if translation_callable:
raw_translation_callable = translation_callable
translation_callable = lambda request: raw_translation_callable({**request, "purpose": "Chinese-to-English image prompt translation and structured visual decomposition"})
if moderation_callable:
raw_moderation_callable = moderation_callable
moderation_callable = lambda request: raw_moderation_callable({**request, "purpose": "image prompt content risk classification"})
return GenerationService(
workflow_service=create_workflow_service(database),
queue_service=QueueService(
repository=JobRepository(database),
audit_service=audit_service,
event_bus=event_bus,
),
image_service=ImageService(
image_repository=ImageRepository(database),
workflow_repository=workflow_repository,
audit_service=audit_service,
),
single_flow_engine=single_flow_engine,
model_provider_service=model_provider_service,
cost_guard_service=CostGuardService(CostService(database)),
prompt_expansion_service=PromptExpansionService(),
event_bus=event_bus,
default_model_route=str(generation_config.get("default_model") or "").strip() or None,
require_resolved_model_route=True,
material_resolver=material_catalog,
material_snapshot_service=WorkflowMaterialSnapshotService(
workflow_repository,
material_catalog,
),
model_assignments=model_assignments,
prompt_translation_service=PromptTranslationService(translation_config, translation_callable),
prompt_semantic_normalizer=PromptSemanticNormalizer(),
prompt_moderation_service=PromptModerationService(moderation_config, moderation_callable),
generation_route_service=GenerationRouteService(routing_config),
image_moderation_service=ImageModerationService(image_moderation_config, image_moderation_callable),
)