Finding Stocks Where Analysts and the Market Disagree

    	
            import lseg.data as ld



import pandas as pd

import numpy as np

import plotly.express as px

import plotly.graph_objects as go

from scipy import stats

from IPython.display import display, HTML

import warnings

warnings.filterwarnings("ignore", category=FutureWarning)



pd.set_option("display.max_colwidth", 80)

pd.set_option("display.max_columns", 20)

pd.set_option("display.float_format", "{:.4f}".format)



# Prevent data cells from wrapping (headers can still wrap)

display(HTML("<style>.dataframe td { white-space: nowrap; }</style>"))
        
        Copy
    

    	
            
# Establish communication with our LSEG data environment.
# Initialize the session - Desktop mode (Workspace)
ld.open_session()

        
        Copy
    

    	
            # --- Screen Parameters ---



# Universe: S&P 500 constituents

UNIVERSE = "0#.SPX"



# Estimate revision lookback

REVISION_PERIOD = "FY1"          # Current fiscal year estimates

REVISION_WINDOW = "30d"          # Count revisions within this window (1d, 3d, 7d, 14d, 30d, 60d, 90d, 180d)



# Price momentum lookback

MOMENTUM_DAYS = 20               # ~1 month of trading days for short-term momentum

MOMENTUM_DAYS_LONG = 60          # ~3 months for medium-term momentum



# Display

TOP_N = 20                       # Number of top divergences to display



print(f"Universe: {UNIVERSE}")

print(f"Estimate period: {REVISION_PERIOD} | Revision window: {REVISION_WINDOW}")

print(f"Momentum: {MOMENTUM_DAYS}d (short) / {MOMENTUM_DAYS_LONG}d (medium)")
        
        Copy
    

    	
            # Retrieve I/B/E/S estimate revision data for the universe

estimate_fields = [

    "TR.EPSMean",

    "TR.EPSMean.Date",

    "TR.EPSNumOfEst",

    "TR.EPSStdDev",

    "TR.NumEstRevisingUp",

    "TR.NumEstRevisingDown",

    "TR.MeanPctChg"

]



estimate_params = {

    "Period": REVISION_PERIOD,

    "WP": REVISION_WINDOW

}



estimates_df = ld.get_data(

    universe=UNIVERSE,

    fields=estimate_fields,

    parameters=estimate_params

)



print(f"Estimates retrieved for {len(estimates_df)} instruments...sample of 10 rows:")

estimates_df.head(10)
        
        Copy
    

    	
            # Clean and compute revision metrics

estimates_df.columns = ["Instrument", "EPS_Mean", "EPS_Date", "Num_Estimates",

                        "EPS_StdDev", "Rev_Up", "Rev_Down", "EPS_Change_Pct"]



# Drop rows with insufficient data

estimates_clean = estimates_df.dropna(subset=["EPS_Mean", "Rev_Up", "Rev_Down", "Num_Estimates"]).copy()



# Compute revision metrics

estimates_clean["Rev_Total"] = estimates_clean["Rev_Up"] + estimates_clean["Rev_Down"]

estimates_clean["Rev_Net"] = estimates_clean["Rev_Up"] - estimates_clean["Rev_Down"]



# Analyst Conviction Score: net revisions normalized by total analyst coverage

# Range: -1 (all analysts cut) to +1 (all analysts raise)

# Score of 0 = no net revision activity relative to coverage

estimates_clean["Analyst_Conviction"] = estimates_clean["Rev_Net"] / estimates_clean["Num_Estimates"].replace(0, np.nan)



# Coefficient of variation — dispersion relative to mean

estimates_clean["EPS_CV"] = estimates_clean["EPS_StdDev"] / estimates_clean["EPS_Mean"].abs().replace(0, np.nan)



print(f"Stocks with valid revision data: {len(estimates_clean)}")

print(f"\nTop 10 by total revision activity (most analysts revising in the {REVISION_WINDOW} window):")

print(f"(Analyst_Conviction: net revision sentiment normalized by total analyst coverage)")

print(f" Range: -1.0 = bearish outlook (all analysts cut) | 0.0 = neutral | +1.0 = bullish outlook (all analysts raise)")

estimates_clean[["Instrument", "Num_Estimates", "Rev_Up", "Rev_Down", "Rev_Total", "Analyst_Conviction",

                 "EPS_Mean", "EPS_Change_Pct"]].nlargest(10, "Rev_Total")
        
        Copy
    

    	
            # Histogram of analyst conviction across the universe

fig = px.histogram(

    estimates_clean,

    x="Analyst_Conviction",

    nbins=30,

    title="Distribution of Analyst Conviction Scores — S&P 500",

    labels={"Analyst_Conviction": "Analyst Conviction"}

)



# Add reference lines: neutral baseline and median

median_conviction = estimates_clean["Analyst_Conviction"].median()

fig.add_vline(

    x=0,

    line_dash="dash",

    line_color="gray",

    annotation_text="Neutral (0)",

    annotation_position="top"

)

fig.add_vline(

    x=median_conviction,

    line_dash="dot",

    line_color="orange",

    annotation_text=f"Median: {median_conviction:.3f}",

    annotation_position="top"

)



fig.update_layout(

    xaxis_title="Analyst Conviction: Bullish Outlook to Bearish Outlook\n(-1.0 = bearish, all analysts cut | 0.0 = neutral | +1.0 = bullish, all analysts raise)",

    yaxis_title="Number of Stocks",

    bargap=0.1

)

fig.show()



# Summary statistics

print(f"\nUniverse analyst conviction summary:")

print(f"  Median conviction score: {median_conviction:.6f}")

print(f"  Mean conviction score: {estimates_clean['Analyst_Conviction'].mean():.6f}")

print(f"  Strongly bullish (> +0.50): {(estimates_clean['Analyst_Conviction'] > 0.50).sum()}")

print(f"  Strongly bearish (< -0.50): {(estimates_clean['Analyst_Conviction'] < -0.50).sum()}")

print(f"  Neutral (-0.20 to +0.20): {((estimates_clean['Analyst_Conviction'] >= -0.20) & (estimates_clean['Analyst_Conviction'] <= 0.20)).sum()}")

print(f"  Stocks with zero net revisions: {(estimates_clean['Analyst_Conviction'] == 0.0).sum()}")

print(f"  Stocks with no revisions: {estimates_clean['Analyst_Conviction'].isna().sum()}")
        
        Copy
    

    	
            # Retrieve historical prices for the universe

instruments = estimates_clean["Instrument"].tolist()



price_history = ld.get_history(

    universe=instruments,

    fields=["TRDPRC_1", "ACVOL_UNS"],

    interval="daily",

    count=MOMENTUM_DAYS_LONG + 5  # A few extra days for buffer

)



print(f"Price history shape: {price_history.shape}")

price_history.head()
        
        Copy
    

    	
            
# Compute momentum metrics from price history
def compute_momentum(df, instrument_col="Instrument"):
    """Compute short and medium-term returns and volume metrics."""
    results = []
 
    # Handle multi-level column structure from get_history
    if isinstance(df.columns, pd.MultiIndex):
        instruments_in_data = df.columns.get_level_values(0).unique()
    else:
        instruments_in_data = [df.columns[0]]  # Single instrument fallback
 
    for inst in instruments_in_data:
        try:
            if isinstance(df.columns, pd.MultiIndex):
                close = df[(inst, "TRDPRC_1")].dropna()
                volume = df[(inst, "ACVOL_UNS")].dropna()
            else:
                close = df["TRDPRC_1"].dropna()
                volume = df["ACVOL_UNS"].dropna()
 
            if len(close) < MOMENTUM_DAYS:
                continue
 
            # Returns in percent terms
            ret_short_pct = (close.iloc[-1] / close.iloc[-MOMENTUM_DAYS] - 1) * 100
            ret_medium_pct = (close.iloc[-1] / close.iloc[0] - 1) * 100 if len(close) >= MOMENTUM_DAYS_LONG else np.nan
 
            # Volume ratio: recent 5-day average vs immediately preceding baseline window.
            # This avoids global drift bias that can occur with full-sample averages.
            if len(volume) >= 10:
                vol_recent = volume.iloc[-5:].mean()
                baseline_window = volume.iloc[-(MOMENTUM_DAYS + 5):-5]
 
                if len(baseline_window) >= 5:
                    vol_baseline = baseline_window.median()
                else:
                    vol_baseline = volume.iloc[:-5].median() if len(volume.iloc[:-5]) > 0 else np.nan
 
                vol_ratio = vol_recent / vol_baseline if pd.notna(vol_baseline) and vol_baseline > 0 else np.nan
            else:
                vol_ratio = np.nan
 
            results.append({
                "Instrument": inst,
                "Return_Short_Pct": ret_short_pct,
                "Return_Medium_Pct": ret_medium_pct,
                "Volume_Ratio": vol_ratio,
                "Last_Close": close.iloc[-1]
            })
        except (KeyError, IndexError):
            continue
 
    return pd.DataFrame(results)
 
momentum_df = compute_momentum(price_history)
print(f"Momentum computed for {len(momentum_df)} instruments...looking at the top 10 rows:")
momentum_df.head(10)

        
        Copy
    

    	
            
# Merge estimates and momentum
combined = estimates_clean.merge(momentum_df, on="Instrument", how="inner")
print(f"Combined dataset: {len(combined)} stocks with both estimate and price data")
print(f"Ranked by Divergence (Revision Score − Momentum Score) — full universe ({len(combined)} rows):")
 
# Standardize key metrics into z-scores
combined["Conviction_Z"] = stats.zscore(combined["Analyst_Conviction"].fillna(0))
combined["Return_Short_Z"] = stats.zscore(combined["Return_Short_Pct"].fillna(0))
combined["Return_Medium_Z"] = stats.zscore(combined["Return_Medium_Pct"].fillna(0))
 
# Revision score: how strongly is this stock being revised relative to peers?
combined["Revision_Score"] = combined["Conviction_Z"]
 
# Composite momentum score: blend of short and medium term
combined["Momentum_Score"] = (combined["Return_Short_Z"] * 0.6 + combined["Return_Medium_Z"] * 0.4)
 
# Divergence: revision signal minus price reaction
# Positive = estimates improving faster than price (potential opportunity)
# Negative = price running ahead of (or despite) estimate deterioration
combined["Divergence"] = combined["Revision_Score"] - combined["Momentum_Score"]
 
# Show how divergence scores are distributed across the universe
div = combined["Divergence"]
print(f"\nDivergence distribution ({len(combined)} stocks):")
print(f"  > 2.0:          {(div >= 2.0).sum():>3}  (extreme positive)")
print(f"  1.0 to 2.0:     {((div >= 1.0) & (div < 2.0)).sum():>3}  (significant positive)")
print(f"  0.5 to 1.0:     {((div >= 0.5) & (div < 1.0)).sum():>3}  (moderate positive)")
print(f"  -0.5 to 0.5:    {((div >= -0.5) & (div < 0.5)).sum():>3}  (minimal)")
print(f"  -1.0 to -0.5:   {((div >= -1.0) & (div < -0.5)).sum():>3}  (moderate negative)")
print(f"  -2.0 to -1.0:   {((div >= -2.0) & (div < -1.0)).sum():>3}  (significant negative)")
print(f"  < -2.0:          {(div < -2.0).sum():>3}  (extreme negative)")
print(f"\nFull ranked table by Divergence:")
 
combined[["Instrument", "Analyst_Conviction", "EPS_Change_Pct", "Return_Short_Pct",
          "Revision_Score", "Momentum_Score", "Divergence"]].sort_values(
    "Divergence", ascending=False).reset_index(drop=True)

        
        Copy
    

    	
            
# Scatter plot: Revision Score vs Momentum Score
fig = px.scatter(
    combined,
    x="Revision_Score",
    y="Momentum_Score",
    hover_name="Instrument",
    hover_data=["Divergence", "Analyst_Conviction", "Return_Short_Pct"],
    color="Divergence",
    color_continuous_scale="RdYlGn",
    color_continuous_midpoint=0,
    title="Where Analyst Revisions and Price Momentum Disagree — S&P 500",
    labels={
        "Revision_Score": "Revision Score (z-scored)",
        "Momentum_Score": "Momentum Score (z-scored)",
        "Divergence": "Divergence"
    }
)
 
# Custom hover template: clean, focused, 2 decimals
fig.update_traces(
    hovertemplate="<b>%{hovertext}</b><br>" +
                  "Divergence: %{customdata[0]:.2f}<br>" +
                  "Analyst Conviction: %{customdata[1]:.2f}<br>" +
                  "Price Return (1mo): %{customdata[2]:.2f}%<br>" +
                  "<extra></extra>"
)
 
# Add diagonal reference line (no divergence)
axis_range = [-3, 3]
fig.add_trace(go.Scatter(
    x=axis_range, y=axis_range,
    mode="lines",
    line=dict(dash="dash", color="gray", width=1),
    showlegend=False,
    hoverinfo="skip"
))
 
# Add quadrant lines
fig.add_hline(y=0, line_dash="dot", line_color="lightgray")
fig.add_vline(x=0, line_dash="dot", line_color="lightgray")
 
fig.update_layout(
    template="plotly_white",
    width=800,
    height=650
)
 
fig.show()

        
        Copy
    

    	
            
# Filter for meaningful signals (avoid noise from low-revision-activity stocks)
actionable = combined[
    (combined["Rev_Total"] >= 3) &  # At least 3 revisions in the window
    (combined["Num_Estimates"] >= 5)  # Reasonable analyst coverage
].copy()
 
# Add sector context directly to Chapter 6 output
try:
    sector_data = ld.get_data(
        universe=actionable["Instrument"].tolist(),
        fields=["TR.TRBCEconomicSector"]
    )
    sector_data.columns = ["Instrument", "Sector"]
    actionable = actionable.merge(sector_data, on="Instrument", how="left")
except Exception:
    actionable["Sector"] = pd.NA
 
print(f"Stocks with sufficient revision activity: {len(actionable)} of {len(combined)}")
print(f"\nFull ranked view by Divergence (positive to negative):")
 
divergence_ranked = actionable[[
    "Instrument", "Sector", "EPS_Mean", "Rev_Up", "Rev_Down", "Analyst_Conviction",
    "Return_Short_Pct", "Revision_Score", "Momentum_Score", "Divergence"
]].sort_values("Divergence", ascending=False).reset_index(drop=True)
 
divergence_ranked

        
        Copy
    

    	
            
# Optional quick check: extremes from both tails
print(f"Highest divergence in filtered set: {divergence_ranked['Divergence'].max():.2f}")
print(f"Lowest divergence in filtered set:  {divergence_ranked['Divergence'].min():.2f}")
print("Top and bottom tails are visible directly in the ranked table preview.")

        
        Copy
    

    	
            
# Retrieve estimate history for the top 5 positive divergence stocks
top_5_instruments = divergence_ranked["Instrument"].head(5).tolist()
 
# Get weekly mean estimates over the past 12 weeks
estimate_history_fields = ["TR.EPSMean", "TR.EPSMean.Date"]
 
estimate_histories = []
 
for inst in top_5_instruments:
    try:
        hist = ld.get_data(
            universe=inst,
            fields=estimate_history_fields,
            parameters={
                "Period": REVISION_PERIOD,
                "SDate": "-12W",
                "EDate": "0",
                "Frq": "W"
            }
        )
        if hist is not None and len(hist) > 0:
            hist["Instrument_Label"] = inst
            estimate_histories.append(hist)
    except Exception:
        continue
 
if estimate_histories:
    all_histories = pd.concat(estimate_histories, ignore_index=True)
    print(f"Retrieved estimate history for {len(estimate_histories)} instruments")
    all_histories.head()

        
        Copy
    

    	
            
# Visualize estimate trajectory for top positive divergences
if estimate_histories:
    # Find EPS and date columns dynamically (column names can vary by API response)
    value_cols = [c for c in all_histories.columns if c not in ["Instrument", "Instrument_Label"]]
    eps_col = next(c for c in value_cols if "date" not in c.lower())
    date_col = next((c for c in value_cols if "date" in c.lower()), None)
 
    plot_df = all_histories.copy()
    hover_data = {}
 
    # Keep a sequential x-axis to visually separate each stock's weekly path
    # while still showing the true snapshot date on hover.
    if date_col:
        plot_df[date_col] = pd.to_datetime(plot_df[date_col], errors="coerce")
        plot_df = plot_df.sort_values(["Instrument_Label", date_col]).reset_index(drop=True)
        hover_data[date_col] = "|%Y-%m-%d"
    else:
        plot_df = plot_df.reset_index(drop=True)
 
    plot_df["Weekly_Measure"] = plot_df.index + 1
 
    fig = px.line(
        plot_df,
        x="Weekly_Measure",
        y=eps_col,
        color="Instrument_Label",
        title="Consensus EPS Trajectory — Top Positive Divergences (12 Weeks)",
        labels={
            eps_col: "Mean EPS Estimate",
            "Instrument_Label": "Stock",
            "Weekly_Measure": "Weekly Measures"
        },
        hover_data=hover_data,
        markers=True
    )
 
    # Hide numeric x-axis scale to avoid implying a time-continuous axis (e.g., 0-60).
    fig.update_xaxes(showticklabels=False)
 
    # Keep hover focused on stock/date/estimate, not plotting index.
    fig.update_traces(
        hovertemplate="Stock=%{fullData.name}<br>Snapshot Date=%{customdata[0]|%Y-%m-%d}<br>Mean EPS Estimate=%{y:.4f}<extra></extra>" if date_col
        else "Stock=%{fullData.name}<br>Mean EPS Estimate=%{y:.4f}<extra></extra>"
    )
 
    fig.update_layout(
        template="plotly_white",
        legend=dict(yanchor="top", y=0.99, xanchor="left", x=0.01)
    )
    fig.show()
else:
    print("No estimate history available for visualization.")

        
        Copy
    

    	
            
# Retrieve sector classification for context (reuse Chapter 6 sector when available)
actionable_with_sector = actionable.copy()
 
if "Sector" not in actionable_with_sector.columns:
    sector_data = ld.get_data(
        universe=actionable_with_sector["Instrument"].tolist(),
        fields=["TR.TRBCEconomicSector"]
    )
    sector_data.columns = ["Instrument", "Sector"]
    actionable_with_sector = actionable_with_sector.merge(sector_data, on="Instrument", how="left")
else:
    missing_sector_mask = actionable_with_sector["Sector"].isna()
    if missing_sector_mask.any():
        sector_data = ld.get_data(
            universe=actionable_with_sector.loc[missing_sector_mask, "Instrument"].tolist(),
            fields=["TR.TRBCEconomicSector"]
        )
        sector_data.columns = ["Instrument", "Sector"]
        actionable_with_sector = actionable_with_sector.merge(
            sector_data,
            on="Instrument",
            how="left",
            suffixes=("", "_new")
        )
        actionable_with_sector["Sector"] = actionable_with_sector["Sector"].fillna(
            actionable_with_sector["Sector_new"]
        )
        actionable_with_sector = actionable_with_sector.drop(columns=["Sector_new"])
 
# Sector-level revision and momentum averages
sector_summary = actionable_with_sector.groupby("Sector").agg(
    Count=("Instrument", "count"),
    Avg_Analyst_Conviction=("Analyst_Conviction", "mean"),
    Avg_EPS_Change_Pct=("EPS_Change_Pct", "mean"),
    Avg_Return_Short_Pct=("Return_Short_Pct", "mean"),
    Avg_Divergence=("Divergence", "mean")
).sort_values("Avg_Divergence", ascending=False)
 
sector_summary

        
        Copy
    

    	
            
# Visualize sector divergences
fig = px.bar(
    sector_summary.reset_index(),
    x="Sector",
    y="Avg_Divergence",
    color="Avg_Divergence",
    color_continuous_scale="RdYlGn",
    color_continuous_midpoint=0,
    hover_data={"Count": True, "Avg_Analyst_Conviction": ":.2f", "Avg_Return_Short_Pct": ":.1f"},
    title="Average Revision-Momentum Divergence by Sector",
    labels={"Avg_Divergence": "Avg Divergence Score", "Count": "Stocks in Sector"}
)
 
fig.update_layout(
    template="plotly_white",
    xaxis_tickangle=-45
)
 
fig.show()

        
        Copy
    

    	
            
# Scatter: Divergence vs Volume Ratio for actionable names
plot_data = actionable.copy()
 
# Ensure Volume_Ratio is present on the plotting frame.
if "Volume_Ratio" not in plot_data.columns:
    plot_data = plot_data.merge(
        momentum_df[["Instrument", "Volume_Ratio"]],
        on="Instrument",
        how="left"
    )
 
# Volume-ratio sanity diagnostics
vol_actionable = plot_data["Volume_Ratio"].dropna()
vol_combined = combined["Volume_Ratio"].dropna() if "Volume_Ratio" in combined.columns else pd.Series(dtype=float)
universe_median_ratio = vol_combined.median() if len(vol_combined) > 0 else 1.0
 
if len(vol_combined) > 0:
    print(
        f"Raw Volume_Ratio > 1.0 in full universe (combined): "
        f"{(vol_combined > 1.0).mean() * 100:.1f}% "
        f"({(vol_combined > 1.0).sum()} of {len(vol_combined)})"
    )
 
print(
    f"Raw Volume_Ratio > 1.0 in actionable subset: "
    f"{(vol_actionable > 1.0).mean() * 100:.1f}% "
    f"({(vol_actionable > 1.0).sum()} of {len(vol_actionable)})"
)
print(
    f"Universe median raw Volume_Ratio: {universe_median_ratio:.2f}"
)
 
# Regime-adjusted ratio: 1.0 means "at universe median volume regime".
plot_data["Volume_Ratio_RegimeAdj"] = plot_data["Volume_Ratio"] / universe_median_ratio
vol_actionable_regime = plot_data["Volume_Ratio_RegimeAdj"].dropna()
print(
    f"Regime-adjusted Volume_Ratio > 1.0 in actionable subset: "
    f"{(vol_actionable_regime > 1.0).mean() * 100:.1f}% "
    f"({(vol_actionable_regime > 1.0).sum()} of {len(vol_actionable_regime)})"
)
 
fig = px.scatter(
    plot_data,
    x="Divergence",
    y="Volume_Ratio_RegimeAdj",
    hover_name="Instrument",
    hover_data={
        "Analyst_Conviction": ":.2f",
        "Return_Short_Pct": ":.2f",
        "Volume_Ratio": ":.2f",
        "Volume_Ratio_RegimeAdj": False
    },
    color="Divergence",
    color_continuous_scale="RdYlGn",
    color_continuous_midpoint=0,
    title="Divergence vs. Volume Confirmation (Regime-Adjusted)",
    labels={
        "Divergence": "Revision-Momentum Divergence",
        "Volume_Ratio_RegimeAdj": "Volume Ratio vs Universe Median"
    }
)
 
# Match Chapter 5 hover style: concise fields, rounded values, no extra trace info.
fig.update_traces(
    hovertemplate="<b>%{hovertext}</b><br>" +
                  "Divergence: %{x:.2f}<br>" +
                  "Volume vs Universe Median: %{y:.2f}<br>" +
                  "Raw Recent/Average Volume Ratio: %{customdata[2]:.2f}<br>" +
                  "Analyst Conviction: %{customdata[0]:.2f}<br>" +
                  "Price Return (1mo): %{customdata[1]:.2f}%<br>" +
                  "<extra></extra>"
)
 
fig.add_hline(y=1.0, line_dash="dash", line_color="gray",
              annotation_text="Universe-median volume regime")
 
fig.update_layout(template="plotly_white", width=800, height=500)
fig.show()

        
        Copy
    

    	
            
# Composite signal: prioritize high divergence with regime-adjusted volume confirmation
screen_output = actionable.copy()
 
# Ensure Volume_Ratio is present on the final scoring frame.
if "Volume_Ratio" not in screen_output.columns:
    screen_output = screen_output.merge(
        momentum_df[["Instrument", "Volume_Ratio"]],
        on="Instrument",
        how="left"
    )
 
# Regime adjustment baseline from the full universe used in scoring.
vol_combined = combined["Volume_Ratio"].dropna() if "Volume_Ratio" in combined.columns else pd.Series(dtype=float)
universe_median_ratio = vol_combined.median() if len(vol_combined) > 0 else 1.0
 
# Convert raw volume ratio to a regime-relative measure.
screen_output["Volume_Ratio_RegimeAdj"] = screen_output["Volume_Ratio"] / universe_median_ratio
 
# Normalize regime-adjusted volume to z-score.
screen_output["Volume_Regime_Z"] = stats.zscore(screen_output["Volume_Ratio_RegimeAdj"].fillna(1.0))
 
# Composite score: divergence + relative volume confirmation bonus.
screen_output["Composite_Score"] = (
    screen_output["Divergence"] * 0.7 +
    screen_output["Volume_Regime_Z"].clip(0, None) * 0.3  # Only reward above-regime participation
)
 
# Final ranked output
weekly_screen = screen_output.nlargest(TOP_N, "Composite_Score")[[
    "Instrument", "Sector", "EPS_Mean", "Analyst_Conviction", "Return_Short_Pct",
    "Volume_Ratio", "Volume_Ratio_RegimeAdj", "Divergence", "Composite_Score"
]].reset_index(drop=True)
 
weekly_screen.index = weekly_screen.index + 1  # 1-based rank
weekly_screen.index.name = "Rank"
 
print(f"{'='*80}")
print(f"WEEKLY SCREEN: Top {TOP_N} Stocks — Estimate Revisions + Price Momentum")
print(f"Run date: {pd.Timestamp.now().strftime('%Y-%m-%d')}")
print(f"Universe: {UNIVERSE} | Period: {REVISION_PERIOD} | Revision window: {REVISION_WINDOW}")
print(f"Volume regime baseline (universe median raw ratio): {universe_median_ratio:.2f}")
print(f"{'='*80}")
weekly_screen

        
        Copy