162 行
8.7 KiB
Python
162 行
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),
|
||
|
|
)
|