powerquant-cli 0.2.6__py3-none-any.whl

quant_core/app/factor/schema/selection_report.py

@@ -0,0 +1,116 @@
+"""面向 CLI/Agent 的版本化选股报告契约。"""
+
+import hashlib
+import json
+from datetime import datetime
+from decimal import Decimal
+
+from pydantic import BaseModel, ConfigDict
+
+from quant_core.app.factor.schema.factor_contract import FactorIdentity, FactorSnapshot
+from quant_core.app.factor.schema.selection_types import SelectionDefinition, SelectionResult
+
+SCHEMA_VERSION = "power-quant.selection.v1"
+
+
+class ContributionReport(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    factor: FactorIdentity
+    value: Decimal
+
+
+class SelectedReport(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    instrument_id: str
+    rank: int
+    score: Decimal
+    contributions: tuple[ContributionReport, ...]
+
+
+class ExcludedReport(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    instrument_id: str
+    reason: str
+    factor: FactorIdentity | None = None
+
+
+class SelectionReport(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    schema_version: str = SCHEMA_VERSION
+    selection_id: str
+    decision_time: datetime
+    universe_size: int
+    selected_count: int
+    excluded_count: int
+    dataset_revisions: tuple[str, ...]
+    selected: tuple[SelectedReport, ...]
+    excluded: tuple[ExcludedReport, ...]
+
+
+def build_selection_report(
+    definition: SelectionDefinition,
+    universe: tuple[str, ...] | list[str],
+    snapshot: FactorSnapshot,
+    result: SelectionResult,
+) -> SelectionReport:
+    payload = {
+        "factors": [
+            {
+                "identity": factor.identity.model_dump(mode="json"),
+                "weight": str(factor.weight),
+                "direction": factor.direction.value,
+                "transform": {
+                    "winsorization": factor.transform.winsorization.value,
+                    "normalization": factor.transform.normalization.value,
+                    "neutralization": factor.transform.neutralization.value,
+                },
+            }
+            for factor in definition.factors
+        ],
+        "top_n": definition.top_n,
+        "missing_policy": definition.missing_policy.value,
+    }
+    selection_id = hashlib.sha256(
+        json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()
+    ).hexdigest()[:24]
+    revisions = tuple(
+        sorted(
+            {
+                row.provenance.dataset_revision
+                for row in snapshot.values
+                if row.provenance.dataset_revision is not None
+            }
+        )
+    )
+    return SelectionReport(
+        selection_id=selection_id,
+        decision_time=snapshot.decision_time,
+        universe_size=len(set(universe)),
+        selected_count=len(result.selected),
+        excluded_count=len(result.excluded),
+        dataset_revisions=revisions,
+        selected=tuple(
+            SelectedReport(
+                instrument_id=row.instrument_id,
+                rank=row.rank,
+                score=row.score,
+                contributions=tuple(
+                    ContributionReport(factor=factor, value=value)
+                    for factor, value in row.contributions
+                ),
+            )
+            for row in result.selected
+        ),
+        excluded=tuple(
+            ExcludedReport(
+                instrument_id=row.instrument_id,
+                reason=row.reason,
+                factor=row.factor,
+            )
+            for row in result.excluded
+        ),
+    )

quant_core/app/factor/schema/selection_types.py

@@ -0,0 +1,135 @@
+"""T5 显式配置与可审计结果；不承载 Provider/订单语义。"""
+
+from dataclasses import dataclass
+from datetime import datetime
+from decimal import Decimal
+from enum import Enum
+
+from quant_core.app.factor.schema.factor_contract import FactorIdentity
+
+
+class SortDirection(str, Enum):
+    ASC = "asc"
+    DESC = "desc"
+
+
+class MissingPolicy(str, Enum):
+    EXCLUDE = "exclude"
+    ERROR = "error"
+
+
+class NormalizationMethod(str, Enum):
+    NONE = "none"
+    RANK = "rank"
+    ZSCORE = "zscore"
+
+
+class WinsorizationMethod(str, Enum):
+    NONE = "none"
+    MAD = "mad"
+    PERCENTILE = "percentile"
+
+
+class NeutralizationMethod(str, Enum):
+    NONE = "none"
+    INDUSTRY = "industry"
+    SIZE = "size"
+    INDUSTRY_SIZE = "industry_size"
+
+
+@dataclass(frozen=True)
+class SelectionExposure:
+    industry: str | None = None
+    size: Decimal | None = None
+    available_at: datetime | None = None
+    dataset_revision: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.available_at is not None and self.available_at.utcoffset() is None:
+            raise ValueError("exposure 可见时间必须带时区")
+        if self.size is not None and (not self.size.is_finite() or self.size <= 0):
+            raise ValueError("exposure 市值必须为有限正值")
+
+
+@dataclass(frozen=True)
+class FactorTransform:
+    """单个因子的横截面预处理；默认保持原始值，避免隐式改变旧口径。"""
+
+    winsorization: WinsorizationMethod = WinsorizationMethod.NONE
+    normalization: NormalizationMethod = NormalizationMethod.NONE
+    lower_quantile: Decimal = Decimal("0.01")
+    upper_quantile: Decimal = Decimal("0.99")
+    mad_scale: Decimal = Decimal("3")
+    neutralization: NeutralizationMethod = NeutralizationMethod.NONE
+
+    def __post_init__(self) -> None:
+        if not Decimal(0) <= self.lower_quantile < self.upper_quantile <= Decimal(1):
+            raise ValueError("winsorize quantile 必须满足 0 <= lower < upper <= 1")
+        if self.mad_scale <= 0:
+            raise ValueError("mad_scale 必须大于 0")
+
+
+@dataclass(frozen=True)
+class FactorWeight:
+    identity: FactorIdentity
+    weight: Decimal
+    direction: SortDirection = SortDirection.DESC
+    transform: FactorTransform = FactorTransform()
+
+    def __post_init__(self) -> None:
+        if not self.weight.is_finite() or self.weight <= 0:
+            raise ValueError("factor weight 必须为正的有限 Decimal")
+
+
+@dataclass(frozen=True)
+class FactorFilter:
+    identity: FactorIdentity
+    minimum: Decimal | None = None
+    maximum: Decimal | None = None
+
+    def __post_init__(self) -> None:
+        if self.minimum is None and self.maximum is None:
+            raise ValueError("filter 至少指定 minimum 或 maximum")
+        if self.minimum is not None and self.maximum is not None and self.minimum > self.maximum:
+            raise ValueError("filter minimum 不得大于 maximum")
+
+
+@dataclass(frozen=True)
+class SelectionDefinition:
+    factors: tuple[FactorWeight, ...]
+    top_n: int
+    filters: tuple[FactorFilter, ...] = ()
+    missing_policy: MissingPolicy = MissingPolicy.EXCLUDE
+
+    def __post_init__(self) -> None:
+        if not self.factors or self.top_n < 1:
+            raise ValueError("selection 必须有因子且 top_n >= 1")
+        keys = [factor.identity.logical_key for factor in self.factors]
+        if len(keys) != len(set(keys)):
+            raise ValueError("duplicate factor identity in selection")
+
+
+@dataclass(frozen=True)
+class SelectedInstrument:
+    instrument_id: str
+    score: Decimal
+    contributions: tuple[tuple[FactorIdentity, Decimal], ...]
+    rank: int
+
+
+@dataclass(frozen=True)
+class ExcludedInstrument:
+    instrument_id: str
+    reason: str
+    factor: FactorIdentity | None = None
+    score: Decimal | None = None
+    contributions: tuple[tuple[FactorIdentity, Decimal], ...] = ()
+
+
+@dataclass(frozen=True)
+class SelectionResult:
+    selected: tuple[SelectedInstrument, ...]
+    excluded: tuple[ExcludedInstrument, ...]
+
+    def excluded_by_id(self, instrument_id: str) -> ExcludedInstrument:
+        return next(row for row in self.excluded if row.instrument_id == instrument_id)

quant_core/app/factor/service/__init__.py

@@ -0,0 +1 @@
+"""Factor Service - 因子同步与查询编排（T3/T4）"""

quant_core/app/factor/service/factor_compute_service.py

@@ -0,0 +1,140 @@
+"""数据库因子定义驱动的 Canonical 因子值生产。"""
+
+import asyncio
+from datetime import date, datetime
+
+from quant_core.app.data.schema.market_schema import BarResponse
+from quant_core.app.factor.constants import (
+    LOCAL_DATASET_REVISION,
+    LOCAL_FACTOR_SOURCE,
+    FactorFrequency,
+    FactorSourceKind,
+    FactorStatus,
+)
+from quant_core.app.factor.exceptions import (
+    FactorNotRegisteredException,
+    InsufficientFactorHistoryError,
+)
+from quant_core.app.factor.interface.factor_execution import WindowExecutor
+from quant_core.app.factor.schema.factor_compute_request import FactorComputeRequest
+from quant_core.app.factor.schema.factor_contract import (
+    FactorDefinition,
+    FactorIdentity,
+    FactorProvenance,
+    FactorValue,
+)
+from quant_core.app.factor.visibility import next_trading_day_open
+
+
+class FactorComputeService:
+    """只接收已持久化定义；源码执行方式由注入的 Runner 决定。"""
+
+    def __init__(
+        self,
+        trading_days: list[date],
+        definitions: list[FactorDefinition],
+        runner: WindowExecutor,
+    ) -> None:
+        self._trading_days = sorted(trading_days)
+        self._definitions = {item.identity: item for item in definitions}
+        if len(self._definitions) != len(definitions):
+            raise ValueError("同次计算不能含重复的完整因子身份")
+        self._runner = runner
+
+    def get(self, name: str | FactorIdentity) -> FactorDefinition:
+        """按完整身份解析；旧名称入口仅允许唯一匹配。"""
+        if isinstance(name, FactorIdentity):
+            definition = self._definitions.get(name)
+        else:
+            matches = [item for key, item in self._definitions.items() if key.name == name]
+            if len(matches) > 1:
+                raise ValueError(f"因子名称存在歧义，必须指定完整身份: {name}")
+            definition = matches[0] if matches else None
+        if definition is None:
+            raise FactorNotRegisteredException(str(name))
+        return definition
+
+    def definitions(self) -> list[FactorDefinition]:
+        return list(self._definitions.values())
+
+    async def compute(
+        self,
+        factor_name: str,
+        instrument_id: str,
+        event_time: datetime,
+        bars: list[BarResponse],
+        *,
+        dataset_revision: str = LOCAL_DATASET_REVISION,
+        input_digest: str | None = None,
+    ) -> FactorValue:
+        result = await self.compute_many(
+            [FactorComputeRequest(factor_name, instrument_id, event_time, bars, input_digest)],
+            dataset_revision=dataset_revision,
+        )
+        return result[0]
+
+    async def compute_many(
+        self,
+        requests: list[FactorComputeRequest],
+        *,
+        dataset_revision: str,
+    ) -> list[FactorValue]:
+        """先完成时点/频率校验，再将所有可计算格打包交给 Runner。"""
+        prepared: list[tuple[FactorComputeRequest, FactorDefinition, datetime, int | None]] = []
+        calls: list[tuple[str, list[BarResponse], dict]] = []
+        for request in requests:
+            definition = self.get(request.identity or request.factor_name)
+            spec = definition.computation_spec
+            if spec is None or definition.provenance_template is None:
+                raise ValueError("因子定义缺少 Python 源码或摘要")
+            if definition.identity.source != LOCAL_FACTOR_SOURCE:
+                raise ValueError("只执行本地 Python 因子")
+            if spec.input_kind != "window":
+                raise ValueError("面板因子必须按完整横截面计算")
+            if spec.frequency is not FactorFrequency.DAILY:
+                raise NotImplementedError("分钟因子计算尚未实现；不能套用日频可见口径")
+            if any(bar.frequency != spec.frequency.value for bar in request.bars):
+                raise ValueError("输入 Bar 频率与因子定义不一致")
+            available_at = next_trading_day_open(request.event_time.date(), self._trading_days)
+            if available_at is None:
+                raise InsufficientFactorHistoryError(
+                    f"交易日历无 {request.event_time.date()} 的下一交易日"
+                )
+            call_index = None
+            if len(request.bars) >= spec.lookback:
+                call_index = len(calls)
+                calls.append((spec.python_source, list(request.bars), spec.parameters))
+            prepared.append((request, definition, available_at, call_index))
+        computed = await asyncio.to_thread(self._runner, calls) if calls else []
+        if len(computed) != len(calls):
+            raise ValueError("因子执行结果数与请求数不一致")
+        results: list[FactorValue] = []
+        for request, definition, available_at, call_index in prepared:
+            value = computed[call_index] if call_index is not None else None
+            template = definition.provenance_template
+            assert template is not None
+            results.append(
+                FactorValue(
+                    identity=definition.identity,
+                    instrument_id=request.instrument_id,
+                    as_of=request.event_time,
+                    available_at=available_at,
+                    value=value,
+                    status=FactorStatus.AVAILABLE if value is not None else FactorStatus.MISSING,
+                    provenance=FactorProvenance(
+                        source_kind=FactorSourceKind.LOCAL_CALCULATOR,
+                        provider_id=LOCAL_FACTOR_SOURCE,
+                        retrieval_ref="python:compute",
+                        content_digest=template.content_digest,
+                        dataset_revision=dataset_revision,
+                        note=(
+                            f"input_sha256={request.input_digest}"
+                            if request.input_digest is not None
+                            else f"bar@{request.bars[-1].timestamp.isoformat()}"
+                            if request.bars
+                            else None
+                        ),
+                    ),
+                )
+            )
+        return results

quant_core/app/factor/service/factor_diagnostic_runner.py

@@ -0,0 +1,134 @@
+"""以真实 PIT 截面和复权历史价构造可解释的因子研究样本。"""
+
+from dataclasses import dataclass
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from zoneinfo import ZoneInfo
+
+from quant_core.app.data.interface.market_data_query import IMarketDataQuery
+from quant_core.app.data.schema.adjustment_schema import AdjustmentType, BarViewRequest
+from quant_core.app.factor.constants import FactorStatus
+from quant_core.app.factor.interface.public.factor_query import IFactorQuery
+from quant_core.app.factor.schema.diagnostic_types import CrossSection, FactorDiagnostics
+from quant_core.app.factor.schema.factor_contract import FactorIdentity
+from quant_core.app.factor.service.factor_diagnostics_service import FactorDiagnosticsService
+
+CN = ZoneInfo("Asia/Shanghai")
+
+
+@dataclass(frozen=True)
+class DiagnosticHorizon:
+    trading_days: int
+    result: FactorDiagnostics
+    paired_samples: int
+
+
+@dataclass(frozen=True)
+class FactorDiagnosticRun:
+    factor: FactorIdentity
+    start: date
+    end: date
+    universe_size: int
+    factor_cells: int
+    available_cells: int
+    price_basis: str
+    horizons: tuple[DiagnosticHorizon, ...]
+
+
+class FactorDiagnosticRunner:
+    """只编排 Market/Factor 公共查询；IC 数学仍由原诊断服务完成。"""
+
+    def __init__(self, market: IMarketDataQuery, factors: IFactorQuery) -> None:
+        self._market = market
+        self._factors = factors
+
+    async def run(
+        self,
+        identity: FactorIdentity,
+        universe: tuple[str, ...],
+        start: date,
+        end: date,
+        horizons: tuple[int, ...] = (1, 5, 10),
+    ) -> FactorDiagnosticRun:
+        if start > end or not universe or not horizons or any(h < 1 for h in horizons):
+            raise ValueError("诊断需要非空股票池、有效日期区间和正的观察窗口")
+        calendar = await self._market.list_trading_days(
+            "XSHG", start, end + timedelta(days=max(horizons) * 3 + 15)
+        )
+        days = [row.trade_date for row in calendar if row.is_open]
+        anchors = [day for day in days if start <= day <= end]
+        positions = {day: index for index, day in enumerate(days)}
+        if not anchors or positions[anchors[-1]] + max(horizons) + 1 >= len(days):
+            raise ValueError("交易日历不足以覆盖因子诊断的前瞻收益窗口")
+        normalized_universe = tuple(sorted(set(universe)))
+        eligible_by_day = {}
+        for day in anchors:
+            listed = {row.instrument_id for row in await self._market.list_instruments_on(day)}
+            eligible_by_day[day] = tuple(
+                instrument_id for instrument_id in normalized_universe if instrument_id in listed
+            )
+        prices: dict[str, dict[date, Decimal]] = {}
+        last_day = days[positions[anchors[-1]] + max(horizons) + 1]
+        for instrument_id in sorted({stock for pool in eligible_by_day.values() for stock in pool}):
+            bars = await self._market.get_adjusted_bars(
+                instrument_id,
+                "1d",
+                BarViewRequest(adjustment_type=AdjustmentType.POST),
+                datetime.combine(start, time.min, tzinfo=CN),
+                datetime.combine(last_day, time.max, tzinfo=CN),
+                100000,
+            )
+            prices[instrument_id] = {
+                bar.timestamp.astimezone(CN).date(): bar.close for bar in bars.bars
+            }
+        sections = {h: [] for h in horizons}
+        available_cells = 0
+        factor_cells = 0
+        for day in anchors:
+            position = positions[day]
+            visible_day = days[position + 1]
+            decision_time = datetime.combine(visible_day, time(9, 31), tzinfo=CN)
+            eligible = eligible_by_day[day]
+            factor_cells += len(eligible)
+            snapshot = await self._factors.get_snapshot(
+                [identity], list(eligible), decision_time, target_as_of=day
+            )
+            factor_values = {
+                row.instrument_id: row.value
+                for row in snapshot.values
+                if row.status is FactorStatus.AVAILABLE and row.value is not None
+            }
+            available_cells += len(factor_values)
+            for horizon in horizons:
+                end_day = days[position + 1 + horizon]
+                returns = {}
+                for instrument_id in factor_values:
+                    base = prices[instrument_id].get(visible_day)
+                    final = prices[instrument_id].get(end_day)
+                    if base is not None and final is not None and base > 0:
+                        returns[instrument_id] = final / base - Decimal(1)
+                sections[horizon].append(CrossSection(day, factor_values, returns))
+        analyzer = FactorDiagnosticsService()
+        return FactorDiagnosticRun(
+            factor=identity,
+            start=start,
+            end=end,
+            universe_size=len(normalized_universe),
+            factor_cells=factor_cells,
+            available_cells=available_cells,
+            price_basis=(
+                "后复权收盘价：因子 T 日收盘归属、T+1 开盘可见；"
+                "收益从 T+1 收盘至 T+1+N 收盘；仅供诊断，不代表成交"
+            ),
+            horizons=tuple(
+                DiagnosticHorizon(
+                    trading_days=horizon,
+                    result=analyzer.analyze(tuple(sections[horizon])),
+                    paired_samples=sum(
+                        len(section.factor_values.keys() & section.forward_returns.keys())
+                        for section in sections[horizon]
+                    ),
+                )
+                for horizon in horizons
+            ),
+        )

quant_core/app/factor/service/factor_diagnostics_service.py

@@ -0,0 +1,140 @@
+"""确定性的纯因子诊断计算；数据提取由调用方负责。"""
+
+from decimal import Decimal, localcontext
+
+from quant_core.app.factor.schema.diagnostic_types import (
+    CrossSection,
+    DecayPoint,
+    FactorDiagnostics,
+    IcPoint,
+    QuantileReturn,
+)
+
+
+class FactorDiagnosticsService:
+    def analyze(
+        self,
+        sections: tuple[CrossSection, ...],
+        *,
+        quantiles: int = 5,
+        selections: tuple[tuple[str, ...], ...] = (),
+        comparison_values: dict[str, Decimal] | None = None,
+        horizon_sections: dict[int, tuple[CrossSection, ...]] | None = None,
+    ) -> FactorDiagnostics:
+        if quantiles < 2:
+            raise ValueError("quantiles 必须至少为 2")
+        points = tuple(
+            self._ic_point(section) for section in sorted(sections, key=lambda x: x.as_of)
+        )
+        return FactorDiagnostics(
+            ic_series=points,
+            quantile_returns=self._quantile_returns(sections, quantiles),
+            decay=self._decay(horizon_sections or {}),
+            selection_turnover=self._turnover(selections),
+            factor_correlation=(
+                _correlation(sections[-1].factor_values, comparison_values)
+                if sections and comparison_values is not None
+                else None
+            ),
+        )
+
+    @staticmethod
+    def _ic_point(section: CrossSection) -> IcPoint:
+        common = sorted(section.factor_values.keys() & section.forward_returns.keys())
+        factor = {key: section.factor_values[key] for key in common}
+        returns = {key: section.forward_returns[key] for key in common}
+        return IcPoint(
+            as_of=section.as_of,
+            ic=_correlation(factor, returns),
+            rank_ic=_correlation(_ranks(factor), _ranks(returns)),
+            sample_size=len(common),
+        )
+
+    @staticmethod
+    def _quantile_returns(
+        sections: tuple[CrossSection, ...], quantiles: int
+    ) -> tuple[QuantileReturn, ...]:
+        buckets: list[list[Decimal]] = [[] for _ in range(quantiles)]
+        for section in sections:
+            common = sorted(
+                section.factor_values.keys() & section.forward_returns.keys(),
+                key=lambda key: (section.factor_values[key], key),
+            )
+            for index, instrument_id in enumerate(common):
+                bucket = min(index * quantiles // len(common), quantiles - 1) if common else 0
+                buckets[bucket].append(section.forward_returns[instrument_id])
+        return tuple(
+            QuantileReturn(
+                quantile=index + 1,
+                mean_return=(sum(values, Decimal(0)) / Decimal(len(values)) if values else None),
+                sample_size=len(values),
+            )
+            for index, values in enumerate(buckets)
+        )
+
+    @staticmethod
+    def _decay(
+        horizon_sections: dict[int, tuple[CrossSection, ...]],
+    ) -> tuple[DecayPoint, ...]:
+        result: list[DecayPoint] = []
+        for horizon, sections in sorted(horizon_sections.items()):
+            if horizon < 1:
+                raise ValueError("decay horizon 必须大于 0")
+            values = [
+                point.rank_ic
+                for point in (FactorDiagnosticsService._ic_point(section) for section in sections)
+                if point.rank_ic is not None
+            ]
+            result.append(
+                DecayPoint(
+                    lag=horizon,
+                    mean_rank_ic=(
+                        sum(values, Decimal(0)) / Decimal(len(values)) if values else None
+                    ),
+                )
+            )
+        return tuple(result)
+
+    @staticmethod
+    def _turnover(selections: tuple[tuple[str, ...], ...]) -> Decimal | None:
+        if len(selections) < 2:
+            return None
+        rates: list[Decimal] = []
+        for previous, current in zip(selections, selections[1:], strict=False):
+            prior = set(previous)
+            now = set(current)
+            denominator = max(len(prior), len(now))
+            rates.append(Decimal(1) - Decimal(len(prior & now)) / Decimal(denominator or 1))
+        return sum(rates, Decimal(0)) / Decimal(len(rates))
+
+
+def _ranks(values: dict[str, Decimal]) -> dict[str, Decimal]:
+    groups: dict[Decimal, list[str]] = {}
+    for key, value in values.items():
+        groups.setdefault(value, []).append(key)
+    result: dict[str, Decimal] = {}
+    cursor = 1
+    for value in sorted(groups):
+        members = groups[value]
+        rank = (Decimal(cursor) + Decimal(cursor + len(members) - 1)) / Decimal(2)
+        result.update({key: rank for key in members})
+        cursor += len(members)
+    return result
+
+
+def _correlation(left: dict[str, Decimal], right: dict[str, Decimal]) -> Decimal | None:
+    keys = sorted(left.keys() & right.keys())
+    if len(keys) < 2:
+        return None
+    left_mean = sum((left[key] for key in keys), Decimal(0)) / Decimal(len(keys))
+    right_mean = sum((right[key] for key in keys), Decimal(0)) / Decimal(len(keys))
+    covariance = sum(
+        ((left[key] - left_mean) * (right[key] - right_mean) for key in keys), Decimal(0)
+    )
+    left_variance = sum(((left[key] - left_mean) ** 2 for key in keys), Decimal(0))
+    right_variance = sum(((right[key] - right_mean) ** 2 for key in keys), Decimal(0))
+    if not left_variance or not right_variance:
+        return None
+    with localcontext() as context:
+        context.prec = 28
+        return covariance / (left_variance * right_variance).sqrt()

quant_core/app/factor/service/factor_exposure_service.py

@@ -0,0 +1,24 @@
+"""通过 Market 已有 PIT 基础指标读取市值暴露；不猜测历史行业分类。"""
+
+import hashlib
+from datetime import datetime
+
+from quant_core.app.data.interface.market_data_query import IMarketDataQuery
+from quant_core.app.factor.schema.selection_types import SelectionExposure
+
+
+async def query_exposures(
+    market: IMarketDataQuery, instrument_ids: tuple[str, ...], decision_time: datetime
+) -> dict[str, SelectionExposure]:
+    """查询指定时点可见市值，行业缺失保持缺值，不推测历史分类。"""
+    rows = await market.list_daily_basic_at(decision_time)
+    selected = set(instrument_ids)
+    return {
+        row.instrument_id: SelectionExposure(
+            size=row.total_market_cap,
+            available_at=decision_time,
+            dataset_revision=hashlib.sha256(row.model_dump_json().encode()).hexdigest(),
+        )
+        for row in rows
+        if row.instrument_id in selected
+    }