o |~j@sdZddlmZmZmZddlmZmZddlmZddl m Z ddl m Z eGdddZ dd ed ed ededededefddZdd edede fddZdefddZ dd ed ed ededededede fddZd S)a fast_pipeline.py [FEATURE 2026-09-11] Live wiring for the "fast_prediction" decision engine: stream_features -> fast_prediction_engine -> fast_entry_gate. Same role as prediction_pipeline.py plays for the "prediction_pipeline" decision engine -- a thin orchestrator, all real logic lives in the engines themselves. Selected via config.json's entry.decision_engine == "fast_prediction". See fast_prediction_engine.py's module docstring for why this path exists (2026-09-10's zero-trade session, the structure_score cold-start + extension-cliff interaction it was built to route around) and for confirmation that stream_features.py itself is completely unchanged -- this only changes how its output is consumed downstream. CALLER-HELD STATE: monitor.py keeps one persistence dict per symbol (Monitor._fast_engine_state) across poll cycles and passes it in as `persistence_state`; this function returns the updated value for the caller to store back. A fresh {} for a symbol is a cold start. ) dataclassfieldasdict)datetimetimezone)compute_features)compute_fast_prediction)evaluate_fast_entryc@seZdZUeed<eed<eed<eedZ eed<eedZ eed<dZ eed<dZ eed <dZ eed <dZeed <dZeed <dZeed <dZeed<dZeed<dZeed<dZeed<dS)FastPipelineDecisionsymbol should_enterconfirmation_score)default_factory reasons_forreasons_againstN direction confidencemomentum volume_state vwap_state ema9_state resistance extensionstategpersistence_seconds_elapsed)__name__ __module__ __qualname__str__annotations__boolfloatrlistrrrrrrrrrrrrr#r#fast_pipeline.pyr s          r Nr barsbars_subavg_vol_baselinersub_bucket_secondspremarket_resultc Csd|pttj}|dd|dit||||||d||d} | |d<t|| ||d} | | fS)aX [FEATURE 2026-09-11 v2] Features + fast_prediction only -- NOT the entry gate. Split out of evaluate_fast_pipeline() so a caller can rank a wider pool of candidates by fast_prediction_engine's own Direction/Confidence reading BEFORE deciding which ones are worth spending a full evaluate_fast_entry() persistence-gate call on. Why this exists: monitor.py._scan_for_entries() used to pick its top-5 entry shortlist by intraday_health.health_score, computed before any fast_prediction reading existed for that cycle -- a chicken-and-egg problem for ranking by confidence instead. Per explicit instruction ("the confidence value should be the value used for selecting the top_5"), monitor.py now calls this for EVERY health-eligible candidate first, ranks by prediction.confidence, and only calls evaluate_fast_entry_only() below for the top 5. Returns (prediction, features) -- both fully computed, so a subsequent evaluate_fast_entry_only() call for a chosen candidate never recomputes either. bars / bars_sub / quote / avg_vol_baseline: same shapes monitor.py already hands prediction_pipeline.evaluate_entry_pipeline(). state: caller-held per-symbol dict, see module docstring. Holds {"prior_features": ..., "persistence_state": ...}. Updates state["prior_features"] as a side effect (unconditionally, even for a candidate that doesn't end up in the top 5 -- its features genuinely evolved this cycle regardless of ranking, and the next cycle's acceleration math needs that real prior reading). prior_featuresNpersistence_state)r(priorr)as_of)r*)rnowrutc setdefaultrr) r r&r'quoter(rr)r.r*features predictionr#r#r$compute_fast_ranking3s   r5returncCsr|pttj}t||||d|d}|j|d<t||j|j|j |j |j |j|j |j |j|j|j|j|j|jdS)a1 Finishes evaluate_fast_pipeline()'s work given an already-computed (prediction, features) pair from compute_fast_ranking() above -- avoids a redundant compute_features() call for a candidate already scored this cycle. Same return shape/contract as evaluate_fast_pipeline() below. r,r.)r r r rrrrrrrrrrrr)rr/rr0r persistencer r rrrrrrrrrrrr)r r4r3rr.decisionr#r#r$evaluate_fast_entry_only`s     r:cCs.t|}|jr |jnd|d<|t|dS)a [FEATURE 2026-09-11 v3] Full raw-indicator snapshot for logging -- not just the classified labels (Strong/Expanding/Bullish/...) that the [FAST] log line and FastPipelineDecision carry, but every underlying numeric/raw value stream_features.py and fast_prediction_engine.py computed this cycle (slope_5m, momentum_acceleration, relative_volume, volume_acceleration, vwap value/slope/classification, price_vs_ema9_pct/ema9_slope, atr_pct, vwap_distance_atr, resistance_level/distance_pct, spread_pct, rsi, etc.). Per explicit instruction ("make sure ... we have all the indicator values logged during the life cycle of the symbol") -- the classified labels alone aren't enough to reconstruct exactly what the engine saw at a given moment; this is the reproducible version. Dumps `features` (a stream_features.StreamFeatures) and `prediction` (a fast_prediction_engine.FastPredictionReading) wholesale via dataclasses.asdict() rather than hand-picking fields, so a new indicator added to either dataclass is captured automatically without this function needing to be updated too. N computed_at)r3r4)rr; isoformat)r3r4fr#r#r$ snapshot_dictvsr>c Cs@|pttj}t|||||||||d \} } t|| | ||dS)aL Convenience wrapper combining compute_fast_ranking() + evaluate_fast_entry_only() for a caller that doesn't need to rank against other candidates first (e.g. a one-off/test evaluation). monitor.py._scan_for_entries() calls the two split functions directly instead -- see compute_fast_ranking()'s docstring. )r)r.r*r7)rr/rr0r5r:) r r&r'r2r(rr)r.r*r4r3r#r#r$evaluate_fast_pipelines    r?)r%NN)N)__doc__ dataclassesrrrrrstream_featuresrfast_prediction_enginerfast_entry_gater r rr"r!dictintr5r:r>r?r#r#r#r$sD    -