from __future__ import annotations import json from statistics import median from typing import Any def build_auction( *, trade_date: str, raw_rows: tuple[dict[str, Any], ...], price_limits: tuple[dict[str, Any], ...], directory: dict[str, dict[str, Any]], prior_snapshot: dict[str, Any], ths_hot: tuple[dict[str, Any], ...], dc_hot: tuple[dict[str, Any], ...], history: list[dict[str, Any]], dynamic: bool, ) -> dict[str, Any]: rows = _normalize_rows(raw_rows, price_limits, directory, dynamic) candidates, focus_rows = _score_candidates(rows, prior_snapshot, ths_hot, dc_hot) scored = {str(item["code"]): item for item in candidates} candidate_codes = {str(item["code"]) for item in candidates} one_price_rows = [ { **item, **scored.get(str(item["code"]), {}), "attention_score": None, "expectation": "", "expected_change": None, "expectation_reason": "竞价价格封于当日涨停价，已从普通异动评分中隔离", } for item in rows if item["is_one_price"] ] one_price_codes = {str(item["code"]) for item in one_price_rows} candidates = [item for item in candidates if item["code"] not in one_price_codes] focus_rows = [item for item in focus_rows if item["code"] not in one_price_codes] one_price_rows.sort( key=lambda item: ( bool(item.get("is_market_core")), _number(item.get("prior_streak")), _number(item.get("amount_million")), ), reverse=True, ) changes = [float(item["change"]) for item in rows] amount_billion = round(sum(float(item["amount_million"]) for item in rows) / 100, 2) amount_history = [item for item in history if item.get("trade_date") != trade_date][-9:] amount_history.append( {"trade_date": trade_date, "amount_billion": amount_billion, "stock_count": len(rows)} ) prior_amounts = [float(item["amount_billion"]) for item in amount_history[:-1]] previous_amount = prior_amounts[-1] if prior_amounts else 0 five_day = prior_amounts[-5:] five_day_average = sum(five_day) / len(five_day) if five_day else 0 eligible = sum( bool(item.get("identifier")) and not str(item.get("name") or "").upper().startswith(("N", "C")) for item in directory.values() ) coverage = min(len(rows) / max(eligible, 1), 1) expectations = { label: sum(item.get("expectation") == label for item in candidates) for label in ("超预期", "符合预期", "低于预期") } return { "trade_date": trade_date, "dynamic": dynamic, "coverage": round(coverage, 4), "summary": { "stock_count": len(rows), "candidate_count": len(candidates), "focus_count": len(focus_rows), "one_price_count": len(one_price_rows), "amount_billion": amount_billion, "amount_change_previous": ( round((amount_billion / previous_amount - 1) * 100, 1) if previous_amount else None ), "amount_change_5d": ( round((amount_billion / five_day_average - 1) * 100, 1) if five_day_average else None ), "median_change": round(median(changes), 2) if changes else None, }, "expectations": expectations, "themes": _theme_evidence(prior_snapshot, candidates + one_price_rows), "amount_history": amount_history, "focus_rows": focus_rows, "one_price_rows": one_price_rows, "_market_rows": rows, "rows": candidates, "all_market_count": len(rows), "candidate_market_count": len(candidate_codes), } def build_watchlist_rows( market_rows: list[dict[str, Any]], candidates: list[dict[str, Any]], one_price_rows: list[dict[str, Any]], watchlist: tuple[dict[str, Any], ...], ) -> list[dict[str, Any]]: market = {str(item["identifier"]): item for item in market_rows} enriched = { str(item["identifier"]): item for item in candidates + one_price_rows } result = [] for saved in watchlist: identifier = str(saved.get("identifier") or "") row = enriched.get(identifier) if row: result.append({**row, "is_watchlist": True, "available": True}) continue raw = market.get(identifier) if raw: actual = _number(raw.get("change")) + _confirmation(raw) item = { **raw, "candidate_sources": ["我的自选"], "source_label": "我的自选", "prior_streak": 0, "concepts": [], "expected_change": 0.0, "actual_strength": round(actual, 2), "expectation": _expectation(actual, 0), "core_tags": [], "is_market_core": False, "is_watchlist": True, "available": True, } item["attention_score"] = _attention(item, 0, False, False) item["expectation_reason"] = "自选观察，按当日竞价强度与成交确认评估" result.append(item) continue result.append( { "identifier": identifier, "code": identifier.split(".")[0], "name": str(saved.get("name") or ""), "sector": str(saved.get("sector") or ""), "is_watchlist": True, "available": False, } ) return sorted( result, key=lambda item: ( bool(item.get("available")), _number(item.get("attention_score")), ), reverse=True, ) def _normalize_rows( raw_rows: tuple[dict[str, Any], ...], price_limits: tuple[dict[str, Any], ...], directory: dict[str, dict[str, Any]], dynamic: bool, ) -> list[dict[str, Any]]: limits = {str(row.get("ts_code") or ""): row for row in price_limits} latest: dict[str, dict[str, Any]] = {} for raw in raw_rows: identifier = str(raw.get("thscode") or raw.get("ts_code") or "").upper() if not identifier or identifier not in directory: continue previous = latest.get(identifier) if previous is None or str(raw.get("time") or "") >= str(previous.get("time") or ""): latest[identifier] = raw rows = [] for identifier, raw in latest.items(): stock = directory[identifier] price = _number(raw.get("latest" if dynamic else "price")) pre_close = _number(raw.get("preClose" if dynamic else "pre_close")) volume = _number(raw.get("volume" if dynamic else "vol")) amount = _number(raw.get("amount")) if amount <= 0 and price > 0 and volume > 0: amount = price * volume if price <= 0 or pre_close <= 0: continue change = (price / pre_close - 1) * 100 up_limit = _number((limits.get(identifier) or {}).get("up_limit")) rows.append( { "identifier": identifier, "code": str(stock.get("code") or identifier.split(".")[0]), "name": str(stock.get("name") or ""), "sector": str(stock.get("sector") or "其他"), "price": round(price, 2), "change": round(change, 2), "amount_million": round(amount / 1_000_000, 2), "turnover_rate": round( _number(raw.get("turnoverRatio" if dynamic else "turnover_rate")), 4 ), "volume_ratio": round( _number(raw.get("volumeRatio" if dynamic else "volume_ratio")), 2 ), "up_limit": round(up_limit, 2) if up_limit else None, "is_one_price": bool( up_limit > 0 and abs(price - up_limit) <= max(0.001, up_limit * 0.00005) ), "snapshot_time": str(raw.get("time") or ""), } ) rows.sort( key=lambda item: (float(item["amount_million"]), float(item["volume_ratio"])), reverse=True, ) return rows def _score_candidates( rows: list[dict[str, Any]], prior_snapshot: dict[str, Any], ths_hot: tuple[dict[str, Any], ...], dc_hot: tuple[dict[str, Any], ...], ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: prior_limits = list(prior_snapshot.get("limits") or []) prior_broken = list(prior_snapshot.get("broken") or []) prior_sectors = list(prior_snapshot.get("sectors") or []) strong_sectors = {str(item.get("name") or "") for item in prior_sectors[:5]} identities: dict[str, dict[str, Any]] = {} core_tags: dict[str, set[str]] = {} def ensure(item: dict[str, Any]) -> tuple[str, dict[str, Any]] | None: code = str(item.get("code") or str(item.get("ts_code") or "").split(".")[0]) if not code: return None return code, identities.setdefault( code, { "sources": [], "streak": 0, "sector": str(item.get("sector") or "其他"), "concepts": [], "ths_rank": None, "dc_rank": None, }, ) highest = max((int(_number(item.get("streak"), 1)) for item in prior_limits), default=0) for item in prior_limits: entry = ensure(item) if not entry: continue code, identity = entry streak = max(1, int(_number(item.get("streak"), 1))) identity["streak"] = streak identity["sources"].append("昨日涨停") if streak >= 3: core_tags.setdefault(code, set()).add("三板以上") if highest and streak == highest: core_tags.setdefault(code, set()).add("市场最高板") for item in prior_broken: entry = ensure(item) if entry and "昨日炸板" not in entry[1]["sources"]: entry[1]["sources"].append("昨日炸板") for sector in prior_sectors[:5]: name = str(sector.get("name") or "") members = [item for item in prior_limits if str(item.get("sector") or "") == name] if members: leader = max( members, key=lambda item: ( int(_number(item.get("streak"), 1)), _number(item.get("amount")), ), ) core_tags.setdefault(str(leader.get("code") or ""), set()).add("题材核心") if prior_limits: leader = max( prior_limits, key=lambda item: ( int(_number(item.get("streak"), 1)), str(item.get("sector") or "") in strong_sectors, _number(item.get("amount")), ), ) core_tags.setdefault(str(leader.get("code") or ""), set()).add("市场领涨") hot_records: dict[str, dict[str, Any]] = {} for rows_source, source, expected_type, rank_key in ( (ths_hot, "同花顺热榜", "热股", "ths_rank"), (dc_hot, "东方财富热榜", "A股市场", "dc_rank"), ): for item in rows_source: if str(item.get("data_type") or "") != expected_type: continue code = str(item.get("ts_code") or "").split(".")[0] rank = max(1, int(_number(item.get("rank"), 9999))) if not code or rank > 20: continue hot = hot_records.setdefault( code, {"ths_rank": None, "dc_rank": None, "concepts": []} ) hot[rank_key] = rank if rank_key == "ths_rank": hot["concepts"] = _concepts(item.get("concept")) identity = identities.setdefault( code, { "sources": [], "streak": 0, "sector": "其他", "concepts": [], "ths_rank": None, "dc_rank": None, }, ) identity[rank_key] = rank identity["concepts"] = hot["concepts"] or identity["concepts"] if source not in identity["sources"]: identity["sources"].append(source) hot_ranked = sorted( hot_records, key=lambda code: ( (21 - (hot_records[code]["ths_rank"] or 21)) * 0.5 + (21 - (hot_records[code]["dc_rank"] or 21)) * 0.25 + (10 if hot_records[code]["ths_rank"] and hot_records[code]["dc_rank"] else 0) ), reverse=True, ) for code in hot_ranked[:5]: core_tags.setdefault(code, set()).add("人气前5") normalized = [] for row in rows: identity = identities.get(str(row["code"])) if not identity: continue ranks = [ rank for rank in (identity.get("ths_rank"), identity.get("dc_rank")) if isinstance(rank, int) ] if ranks and min(ranks) > 10 and len(ranks) == 1 and row["code"] not in core_tags: if not any(source in {"昨日涨停", "昨日炸板"} for source in identity["sources"]): continue streak = int(identity["streak"]) expected = {0: 0.5, 1: 1.5, 2: 3.0, 3: 4.0}.get(streak, 5.0) expected += 0.8 if len(ranks) == 2 else 0.7 if ranks and min(ranks) <= 10 else 0 expected = min(expected, 6.5) confirmation = _confirmation(row) actual_strength = float(row["change"]) + confirmation expectation = _expectation(actual_strength, expected) tags = sorted(core_tags.get(str(row["code"]), set())) scored = { **row, "sector": identity["sector"] if identity["sector"] != "其他" else row["sector"], "candidate_sources": identity["sources"], "source_label": " · ".join(identity["sources"]), "prior_streak": streak, "concepts": identity["concepts"], "expected_change": round(expected, 2), "actual_strength": round(actual_strength, 2), "expectation": expectation, "core_tags": tags, "is_market_core": bool(tags), } scored["attention_score"] = _attention( scored, expected, bool(tags), str(scored["sector"]) in strong_sectors, ) scored["expectation_reason"] = _reason(scored) normalized.append(scored) normalized.sort( key=lambda item: (float(item["attention_score"]), float(item["amount_million"])), reverse=True, ) matched = { str(item["code"]) for item in [row for row in normalized if row["expectation"] == "符合预期"][:20] } mandatory = [item for item in normalized if item["is_market_core"]] optional = [ item for item in normalized if not item["is_market_core"] and ( (item["attention_score"] >= 55 and item["expectation"] != "符合预期") or item["code"] in matched ) ] focus = mandatory + optional[: max(0, 30 - len(mandatory))] focus.sort(key=lambda item: float(item["attention_score"]), reverse=True) return normalized, focus def _confirmation(row: dict[str, Any]) -> float: volume_ratio = _number(row.get("volume_ratio")) turnover = _number(row.get("turnover_rate")) amount = _number(row.get("amount_million")) return ( ( 0.6 if volume_ratio >= 2 else 0.3 if volume_ratio >= 1.2 else -0.5 if volume_ratio < 0.6 else 0 ) + (0.25 if turnover >= 0.15 else -0.25 if turnover < 0.03 else 0) + (0.3 if amount >= 20 else 0.15 if amount >= 5 else -0.3 if amount < 1 else 0) ) def _attention( row: dict[str, Any], expected: float, core: bool, strong_sector: bool ) -> float: sources = list(row.get("candidate_sources") or []) streak = int(row.get("prior_streak") or 0) identity = 35 if core else 27 if streak >= 2 else 21 if sources else 14 deviation = min(30, abs(_number(row.get("change")) - expected) * 5) volume = min(10, max(0, _number(row.get("volume_ratio"))) / 2 * 10) amount = min(6, max(0, _number(row.get("amount_million"))) / 10 * 6) turnover = min(4, max(0, _number(row.get("turnover_rate"))) / 0.2 * 4) theme = 15 if strong_sector else 7 if row.get("concepts") else 0 return round(min(100, identity + deviation + volume + amount + turnover + theme), 1) def _expectation(actual: float, expected: float) -> str: difference = actual - expected return "超预期" if difference >= 1.5 else "低于预期" if difference <= -1.5 else "符合预期" def _reason(row: dict[str, Any]) -> str: streak = int(row.get("prior_streak") or 0) identity = f"昨日{streak}板" if streak > 1 else "昨日首板" if streak else "热榜标的" difference = _number(row.get("change")) - _number(row.get("expected_change")) direction = "高于" if difference > 0 else "低于" if difference < 0 else "贴合" return f"{identity}，竞价涨幅{direction}预期{abs(difference):.1f}个百分点" def _theme_evidence( prior_snapshot: dict[str, Any], rows: list[dict[str, Any]] ) -> dict[str, list[dict[str, Any]]]: prior_sectors = list(prior_snapshot.get("sectors") or []) carry = [] for sector in prior_sectors[:10]: name = str(sector.get("name") or "其他") members = [row for row in rows if str(row.get("sector") or "其他") == name] changes = [_number(row.get("change")) for row in members] middle = median(changes) if changes else None positive = sum(value > 0.2 for value in changes) / len(changes) * 100 if changes else 0 status = ( "强承接" if middle is not None and middle >= 2 and positive >= 60 else "有承接" if middle is not None and middle >= 0 and positive >= 50 else "分歧" if middle is not None and middle > -2 else "承接弱" ) carry.append( { "name": name, "status": status, "prior_limit_count": int(_number(sector.get("count"))), "matched_count": len(members), "median_change": round(middle, 2) if middle is not None else None, "positive_rate": round(positive, 1), } ) prior_names = {str(item.get("name") or "") for item in prior_sectors} groups: dict[str, dict[str, dict[str, Any]]] = {} for row in rows: for concept in row.get("concepts") or []: if concept and concept not in prior_names: groups.setdefault(str(concept), {})[str(row["code"])] = row new_themes = [] for name, mapped in groups.items(): members = list(mapped.values()) changes = [_number(item.get("change")) for item in members] positive_rate = sum(value > 0.2 for value in changes) / len(changes) if len(members) >= 2 and median(changes) >= 2 and positive_rate >= 0.67: new_themes.append( { "name": name, "stock_count": len(members), "median_change": round(median(changes), 2), "leaders": [ str(item.get("name") or "") for item in sorted( members, key=lambda item: _number(item.get("change")), reverse=True, )[:3] ], } ) new_themes.sort(key=lambda item: (item["stock_count"], item["median_change"]), reverse=True) return {"carry": carry, "new_themes": new_themes[:8]} def _concepts(value: Any) -> list[str]: if isinstance(value, list): return [str(item).strip() for item in value if str(item).strip()] text = str(value or "").strip() if not text: return [] try: parsed = json.loads(text) if isinstance(parsed, list): return [str(item).strip() for item in parsed if str(item).strip()] except json.JSONDecodeError: pass return [part.strip() for part in text.replace("，", ",").split(",") if part.strip()] def _number(value: Any, default: float = 0.0) -> float: try: number = float(value) return number if number == number else default except (TypeError, ValueError): return default