qlib/backend/app/api/deps.py

"""API 依赖注入：Repository / 研究服务的装配点（composition root 的一部分）。

路由层统一使用 Annotated 注入（FastAPI 推荐写法，配合 ruff B008 无冲突）。
"""

from __future__ import annotations

from typing import Annotated

from fastapi import Depends
from sqlalchemy.orm import Session

from app.application.services.chart_service import ChartService
from app.application.services.replay_service import ReplayService
from app.application.services.selection_service import SelectionService
from app.application.services.signal_service import SignalService
from app.domain.repositories.composite import CompositeRepository
from app.domain.repositories.factor import FactorRepository
from app.domain.repositories.index import IndexConstituentRepository
from app.domain.repositories.jobs import ExperimentRepository, JobRepository
from app.domain.repositories.market import (
    AdjustFactorRepository,
    DailyBarRepository,
    FinancialRepository,
    StockRepository,
)
from app.domain.repositories.selection import SelectionRepository
from app.domain.repositories.signal import SignalRepository
from app.domain.repositories.strategy import StrategyRepository
from app.infrastructure.persistence.sqlalchemy.repositories.composite_impl import (
    SqlAlchemyCompositeRepository,
)
from app.infrastructure.persistence.sqlalchemy.repositories.factor_impl import (
    SqlAlchemyFactorRepository,
)
from app.infrastructure.persistence.sqlalchemy.repositories.index_impl import (
    SqlAlchemyIndexConstituentRepository,
)
from app.infrastructure.persistence.sqlalchemy.repositories.market_impl import (
    SqlAlchemyAdjustFactorRepository,
    SqlAlchemyDailyBarRepository,
    SqlAlchemyFinancialRepository,
    SqlAlchemyStockRepository,
)
from app.infrastructure.persistence.sqlalchemy.repositories.selection_impl import (
    SqlAlchemySelectionRepository,
)
from app.infrastructure.persistence.sqlalchemy.repositories.signal_impl import (
    SqlAlchemySignalRepository,
)
from app.infrastructure.persistence.sqlalchemy.repositories.strategy_impl import (
    SqlAlchemyStrategyRepository,
)
from app.infrastructure.persistence.sqlalchemy.session import get_session
from app.quant.engine import LocalEngine, QuantEngine
from app.quant.service import ResearchService

DbSession = Annotated[Session, Depends(get_session)]


def _stock_repo_factory(session: DbSession) -> StockRepository:
    return SqlAlchemyStockRepository(session)


def _daily_repo_factory(session: DbSession) -> DailyBarRepository:
    return SqlAlchemyDailyBarRepository(session)


def _financial_repo_factory(session: DbSession) -> FinancialRepository:
    return SqlAlchemyFinancialRepository(session)


def _adjust_repo_factory(session: DbSession) -> AdjustFactorRepository:
    return SqlAlchemyAdjustFactorRepository(session)


def _chart_service_factory(
    stock_repo: Annotated[StockRepository, Depends(_stock_repo_factory)],
    daily_repo: Annotated[DailyBarRepository, Depends(_daily_repo_factory)],
    adj_repo: Annotated[AdjustFactorRepository, Depends(_adjust_repo_factory)],
) -> ChartService:
    return ChartService(stock_repo, daily_repo, adj_repo)


def _index_repo_factory(session: DbSession) -> IndexConstituentRepository:
    return SqlAlchemyIndexConstituentRepository(session)


def _engine_factory() -> QuantEngine:
    return LocalEngine()


def _service_factory(
    stock_repo: Annotated[StockRepository, Depends(_stock_repo_factory)],
    daily_repo: Annotated[DailyBarRepository, Depends(_daily_repo_factory)],
    engine: Annotated[QuantEngine, Depends(_engine_factory)],
    index_repo: Annotated[IndexConstituentRepository, Depends(_index_repo_factory)],
) -> ResearchService:
    return ResearchService(stock_repo, daily_repo, engine, index_repo)


def _replay_service_factory(
    stock_repo: Annotated[StockRepository, Depends(_stock_repo_factory)],
    daily_repo: Annotated[DailyBarRepository, Depends(_daily_repo_factory)],
    index_repo: Annotated[IndexConstituentRepository, Depends(_index_repo_factory)],
) -> ReplayService:
    return ReplayService(stock_repo, daily_repo, index_repo)


def _signal_service_factory(
    stock_repo: Annotated[StockRepository, Depends(_stock_repo_factory)],
    daily_repo: Annotated[DailyBarRepository, Depends(_daily_repo_factory)],
    index_repo: Annotated[IndexConstituentRepository, Depends(_index_repo_factory)],
) -> SignalService:
    return SignalService(stock_repo, daily_repo, index_repo)


def _selection_service_factory(
    stock_repo: Annotated[StockRepository, Depends(_stock_repo_factory)],
    daily_repo: Annotated[DailyBarRepository, Depends(_daily_repo_factory)],
    financial_repo: Annotated[FinancialRepository, Depends(_financial_repo_factory)],
    index_repo: Annotated[IndexConstituentRepository, Depends(_index_repo_factory)],
) -> SelectionService:
    return SelectionService(stock_repo, daily_repo, financial_repo, index_repo)


def _selection_repo_factory(session: DbSession) -> SelectionRepository:
    return SqlAlchemySelectionRepository(session)


def _factor_repo_factory(session: DbSession) -> FactorRepository:
    return SqlAlchemyFactorRepository(session)


def _composite_repo_factory(session: DbSession) -> CompositeRepository:
    return SqlAlchemyCompositeRepository(session)


def _signal_repo_factory(session: DbSession) -> SignalRepository:
    return SqlAlchemySignalRepository(session)


def _strategy_repo_factory(session: DbSession) -> StrategyRepository:
    return SqlAlchemyStrategyRepository(session)


StockRepoDep = Annotated[StockRepository, Depends(_stock_repo_factory)]
DailyRepoDep = Annotated[DailyBarRepository, Depends(_daily_repo_factory)]
EngineDep = Annotated[QuantEngine, Depends(_engine_factory)]
ResearchServiceDep = Annotated[ResearchService, Depends(_service_factory)]
SelectionServiceDep = Annotated[SelectionService, Depends(_selection_service_factory)]
SelectionRepoDep = Annotated[SelectionRepository, Depends(_selection_repo_factory)]
FactorRepoDep = Annotated[FactorRepository, Depends(_factor_repo_factory)]
CompositeRepoDep = Annotated[CompositeRepository, Depends(_composite_repo_factory)]
SignalRepoDep = Annotated[SignalRepository, Depends(_signal_repo_factory)]
SignalServiceDep = Annotated[SignalService, Depends(_signal_service_factory)]
ReplayServiceDep = Annotated[ReplayService, Depends(_replay_service_factory)]
ChartServiceDep = Annotated[ChartService, Depends(_chart_service_factory)]
StrategyRepoDep = Annotated[StrategyRepository, Depends(_strategy_repo_factory)]


def _job_repo_factory(session: DbSession):
    from app.infrastructure.persistence.sqlalchemy.repositories.jobs_impl import (
        SqlAlchemyJobRepository,
    )

    return SqlAlchemyJobRepository(session)


def _experiment_repo_factory(session: DbSession):
    from app.infrastructure.persistence.sqlalchemy.repositories.jobs_impl import (
        SqlAlchemyExperimentRepository,
    )

    return SqlAlchemyExperimentRepository(session)


JobRepoDep = Annotated[JobRepository, Depends(_job_repo_factory)]
ExperimentRepoDep = Annotated[ExperimentRepository, Depends(_experiment_repo_factory)]