Update app.py

app.py

@@ -1 +1,518 @@
-API_KEY = os.getenv("FMP_API_KEY")
+# app.py — Macro Cycle Composite (2 sections, production style)
+
+import math
+from datetime import datetime, date, timedelta
+
+import numpy as np
+import pandas as pd
+import pandas_datareader.data as web
+import yfinance as yf
+
+import streamlit as st
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import plotly.express as px
+
+# --------------------------- Page config ---------------------------
+st.set_page_config(
+    page_title="Market Cycle Composite",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+st.title("Market Cycle Phases")
+
+st.markdown(
+    "Classifies the market cycle each period: **Early**, **Mid-Late**, **Decline**, or **Uncertain**. "
+    "The solid line is the composite score; the dashed line is S&P 500 YoY. "
+    "Colored bands show the active phase over time. "
+    "Use the sidebar to set the sample start, smoothing, slope lookback, thresholds, and minimum run. "
+    "Click **Run Analysis** to update the charts."
+)
+
+# --------------------------- Constants -----------------------------
+TODAY_PLUS_1 = (date.today() + timedelta(days=1))
+DEFAULT_START = date(2000, 1, 1)
+
+FRED_MAP = {
+    'LEI'               : 'USSLIND',
+    'Philly Manuf Diff' : 'GACDFSA066MSFRBPHI',
+    'Texas Serv Diff'   : 'TSSOSBACTUAMFRBDAL',
+    'Capacity Util'     : 'CUMFNS',
+    'BBK Leading'       : 'BBKMLEIX',
+    'CFNAI 3MMA'        : 'CFNAIMA3',
+    'Core CPI'          : 'CPILFESL',
+    'Core PCE'          : 'PCEPILFE',
+    'Hourly Wage'       : 'CES0500000003',
+    'PPI'               : 'PPIACO',
+    'Commodities'       : 'PALLFNFINDEXM',
+    '10Y'               : 'DGS10',
+    'HY OAS'            : 'BAMLH0A0HYM2',
+    'StLouis FSI'       : 'STLFSI4',
+}
+
+PHASE_COLORS = {
+    'Early'     : '#54d62c',
+    'Mid-Late'  : '#3fa1ff',
+    'Decline'   : '#ff4c4c',
+    'Uncertain' : '#ffd400'
+}
+
+# --------------------------- Caching -------------------------------
+@st.cache_data(show_spinner=False)
+def load_macro_series(start: date, end: date) -> pd.DataFrame:
+    raw = {}
+    for k, tkr in FRED_MAP.items():
+        s = web.DataReader(tkr, 'fred', start, end).squeeze()
+        raw[k] = s
+    df = pd.DataFrame(raw)
+    return df
+
+@st.cache_data(show_spinner=False)
+def load_spx(start: date, end: date) -> pd.Series:
+    data = yf.download('^GSPC', start=start, end=end, auto_adjust=False, progress=False)
+    data.columns = data.columns.get_level_values(0)
+    spx = data['Adj Close'].resample('ME').last().ffill()
+    return spx
+
+# --------------------------- Sidebar -------------------------------
+with st.sidebar:
+    st.title("Parameters")
+
+    with st.expander("Data Range", expanded=False):
+        start_date = st.date_input(
+            "Start Date",
+            value=DEFAULT_START,
+            min_value=date(1950, 1, 1),
+            max_value=TODAY_PLUS_1,
+            help=(
+                "Start date for all series. "
+                "Earlier = more history, heavier load. "
+                "Later = less history."
+            )
+        )
+        st.caption(f"End Date: {TODAY_PLUS_1.isoformat()} (fixed to today + 1)")
+
+        freq = st.selectbox(
+            "Resample Frequency",
+            options=["ME", "QE"],
+            index=0,
+            help=(
+                "Aggregation for all series. "
+                "ME = month end. QE = quarter end. "
+                "Higher aggregation smooths high-frequency noise."
+            )
+        )
+
+    with st.expander("Composite & Phase Parameters", expanded=False):
+        smooth_window = st.number_input(
+            "Composite Smoothing Window (months)",
+            value=2, min_value=1, max_value=12, step=1,
+            help=(
+                "Moving average on the composite. "
+                "Increase to smooth more (slower). "
+                "Decrease to react faster."
+            )
+        )
+        slope_window = st.number_input(
+            "Slope Lookback (months)",
+            value=3, min_value=1, max_value=12, step=1,
+            help=(
+                "Difference span used for slope. "
+                "Higher = coarser trend. "
+                "Lower = more sensitive."
+            )
+        )
+        comp_thr = st.number_input(
+            "Composite Threshold",
+            value=0.15, step=0.05, format="%.2f",
+            help=(
+                "Band around zero for phase changes. "
+                "Increase = fewer flips. "
+                "Decrease = earlier shifts."
+            )
+        )
+        slope_thr = st.number_input(
+            "Slope Threshold",
+            value=0.005, step=0.001, format="%.3f",
+            help=(
+                "Minimum slope for Early/Decline. "
+                "Increase to demand stronger momentum. "
+                "Decrease to catch weaker turns."
+            )
+        )
+        min_run = st.number_input(
+            "Minimum Phase Run (months)",
+            value=6, min_value=1, max_value=24, step=1,
+            help=(
+                "Median/mode filter on phases. "
+                "Higher enforces longer runs. "
+                "Lower allows quicker switches."
+            )
+        )
+
+    run = st.button("Run Analysis", help="Compute the composite and render both sections.")
+
+# --------------------------- Run pipeline --------------------------
+if run:
+    prog = st.progress(0, text="Loading data...")
+    try:
+        # Load & resample
+        with st.spinner("Loading macro series..."):
+            df_raw_daily = load_macro_series(start_date, TODAY_PLUS_1)
+        prog.progress(20, text="Resampling...")
+
+        df = df_raw_daily.resample(freq).last().ffill()
+
+        # ====== TRANSFORMS & COMPOSITE ======
+        yoy     = lambda s: s.pct_change(12) * 100
+        delta12 = lambda s: s.diff(12)
+        invert  = lambda s: -s
+
+        tr = df.copy()
+        tr['LEI']           = yoy(tr['LEI'])
+        tr['Capacity Util'] = yoy(tr['Capacity Util'])
+        tr['BBK Leading']   = yoy(tr['BBK Leading'])
+        for c in ['Core CPI','Core PCE','Hourly Wage','PPI','Commodities']:
+            tr[c] = yoy(tr[c])
+        tr['10Y']         = invert(delta12(tr['10Y']))
+        tr['HY OAS']      = invert(delta12(tr['HY OAS']))
+        tr['StLouis FSI'] = invert(tr['StLouis FSI'])
+
+        infl_cols = ['Core CPI','Core PCE','Hourly Wage','PPI','Commodities']
+        tr['Inflation'] = tr[infl_cols].mean(axis=1)
+
+        inputs = [
+            'LEI','Philly Manuf Diff','Texas Serv Diff',
+            'Capacity Util','BBK Leading','CFNAI 3MMA',
+            'Inflation','10Y','HY OAS','StLouis FSI'
+        ]
+
+        z = tr[inputs].apply(lambda s: (s - s.mean())/s.std())
+        comp = z.mean(axis=1)
+        comp_sm = comp.rolling(int(smooth_window), min_periods=1).mean()
+        slope = comp.diff(int(slope_window))
+
+        # Phase classification
+        cond_early   = (comp < -comp_thr) & (slope >  slope_thr)
+        cond_midlate =  comp >  comp_thr
+        cond_decline = (comp < -comp_thr) & (slope < -slope_thr)
+        cond_unc     = comp.abs() <= comp_thr
+
+        phase = pd.Series('Mid-Late', index=comp.index)
+        phase[cond_early]   = 'Early'
+        phase[cond_decline] = 'Decline'
+        phase[cond_unc]     = 'Uncertain'
+
+        code_map = {'Early':0, 'Mid-Late':1, 'Decline':2, 'Uncertain':3}
+        inv_map  = {v:k for k,v in code_map.items()}
+        codes = phase.map(code_map)
+
+        smoothed_codes = codes.rolling(
+            window=int(min_run), center=True, min_periods=1
+        ).apply(lambda x: pd.Series(x).value_counts().idxmax(), raw=False)
+
+        phase = smoothed_codes.round().astype(int).map(inv_map)
+
+        prog.progress(55, text="Loading equity series...")
+        spx = load_spx(start_date, TODAY_PLUS_1)
+        spx_yoy = spx.pct_change(12) * 100
+        if freq != 'ME':
+            spx_yoy = spx_yoy.resample(freq).last().ffill()
+
+        # ================== SECTION 1 — COMPOSITE ==================
+        st.header("Market Cycle Composite Indicator")
+
+        with st.expander("Methodology", expanded=False):
+            st.markdown("#### What you’re looking at")
+            st.write(
+                "One score that summarizes many macro and market series. "
+                "We also show the S&P 500 YoY for context. "
+                "Colored bands mark the phase we infer at each date."
+            )
+
+            st.markdown("#### How we build the score")
+            st.write("1) Put all series on the same timeline.")
+            st.write("We keep the last value each period and fill gaps with the last known value.")
+            st.latex(r"X^{(F)}_{t} = X_{\tau(t)},\;\; \tau(t)=\text{last timestamp in period }t")
+            st.latex(r"\tilde{X}_t = \begin{cases} X_t, & \text{if observed}\\ \tilde{X}_{t-1}, & \text{if missing}\end{cases}")
+
+            st.write("2) Convert each series to a comparable change.")
+            st.write("Most series use year-over-year percent change:")
+            st.latex(r"\mathrm{YoY}(X_t)=100\left(\frac{X_t}{X_{t-12}}-1\right)")
+            st.write("Rates and spreads use 12-month differences (and we flip the sign when higher is worse):")
+            st.latex(r"\Delta_{12}(X_t)=X_t-X_{t-12},\qquad \tilde{X}_t=-\Delta_{12}(X_t)")
+            st.write("Stress metrics are inverted so higher stress lowers the score:")
+            st.latex(r"\tilde{X}_t=-X_t")
+
+            st.write("3) Build an inflation block from five series and average them:")
+            st.latex(r"\mathrm{Inflation}_t=\frac{1}{5}\sum_{i=1}^{5}X_{i,t}")
+
+            st.write("4) Standardize each input so all have the same scale.")
+            st.latex(r"Z_{i,t}=\frac{X_{i,t}-\mu_i}{\sigma_i}")
+
+            st.write("5) Average the standardized inputs to get the composite.")
+            st.latex(r"C_t=\frac{1}{N}\sum_{i=1}^{N}Z_{i,t}")
+
+            st.write("6) Smooth the composite to cut noise.")
+            st.latex(r"\bar{C}_t=\frac{1}{W}\sum_{k=0}^{W-1}C_{t-k}")
+
+            st.write("7) Measure recent direction with a simple slope.")
+            st.latex(r"S_t=C_t-C_{t-W_s}")
+
+            st.write("8) Assign a phase using two thresholds.")
+            st.latex(r"\text{Early: } C_t<-\theta_c \ \wedge\ S_t>+\theta_s")
+            st.latex(r"\text{Decline: } C_t<-\theta_c \ \wedge\ S_t<-\theta_s")
+            st.latex(r"\text{Mid\text{-}Late: } C_t>+\theta_c")
+            st.latex(r"\text{Uncertain: } |C_t|\le\theta_c")
+
+            st.write("9) Stabilize phases with a centered majority vote over a short window.")
+            st.latex(r"\hat{P}_t=\operatorname{mode}\{P_{t-k},\ldots,P_{t+k}\},\;\; m=2k+1")
+
+            st.markdown("#### How the sidebar settings change results")
+            st.write("- **Resample Frequency**: Month-end or quarter-end. Higher aggregation is smoother.")
+            st.write("- **Composite Smoothing Window**: Larger = smoother, slower to react.")
+            st.write("- **Slope Lookback**: Larger = slower slope, fewer flips.")
+            st.write("- **Composite Threshold**: Larger = fewer phase changes.")
+            st.write("- **Slope Threshold**: Larger = only strong turns count as Early/Decline.")
+            st.write("- **Minimum Phase Run**: Larger = longer required runs, fewer whipsaws.")
+
+        # Composite plot
+        try:
+            fig_comp = make_subplots(specs=[[{"secondary_y": True}]])
+            fig_comp.update_layout(
+                template='plotly_dark',
+                height=520,
+                margin=dict(l=60, r=20, t=60, b=40),
+                title_text='Market-Cycle Composite Indicator',
+                xaxis_rangeslider_visible=False,
+                paper_bgcolor='rgba(0,0,0,1)',
+                plot_bgcolor='rgba(0,0,0,1)',
+                font=dict(color='white'),
+                legend=dict(
+                    bgcolor="rgba(0,0,0,0)",
+                    font=dict(color="white"),
+                    title_font=dict(color="white")
+                )
+            )
+
+            # Phase shading
+            mask = phase.copy()
+            grp = (mask != mask.shift()).cumsum()
+            for ph, color in PHASE_COLORS.items():
+                for _, span in mask[mask == ph].groupby(grp):
+                    x0 = pd.Timestamp(span.index[0]).to_pydatetime()
+                    x1 = pd.Timestamp(span.index[-1]).to_pydatetime()
+                    fig_comp.add_shape(
+                        type="rect",
+                        x0=x0, x1=x1, y0=0, y1=1,
+                        xref="x1", yref="paper",
+                        fillcolor=color, opacity=0.22,
+                        layer="below", line_width=0
+                    )
+
+            # Composite and zero
+            fig_comp.add_trace(
+                go.Scatter(
+                    x=comp_sm.index, y=comp_sm, mode='lines',
+                    line=dict(width=2), name=f'Cycle Composite ({int(smooth_window)}m MA)'
+                ),
+                secondary_y=False
+            )
+            fig_comp.add_hline(y=0, line_color='rgba(255,255,255,0.6)', line_width=1)
+
+            # SPX YoY on secondary axis
+            fig_comp.add_trace(
+                go.Scatter(
+                    x=spx_yoy.index, y=spx_yoy,
+                    mode='lines', line=dict(width=2, dash='dash', color='#00d084'),
+                    name='S&P 500 YoY %'
+                ),
+                secondary_y=True
+            )
+
+            # Legend keys for phases
+            for ph, color in PHASE_COLORS.items():
+                fig_comp.add_trace(
+                    go.Scatter(
+                        x=[None], y=[None], mode='lines',
+                        line=dict(color=color, width=10),
+                        name=ph, showlegend=True
+                    ),
+                    secondary_y=False
+                )
+
+            # Axes styling
+            fig_comp.update_xaxes(
+                tickformat='%Y',
+                dtick="M12",
+                title_font=dict(color="white"),
+                tickfont=dict(color="white"),
+                tickcolor="white",
+                gridcolor="rgba(255,255,255,0.10)",
+                zerolinecolor="rgba(255,255,255,0.15)",
+                linecolor="rgba(255,255,255,0.15)",
+                ticks="outside"
+            )
+            fig_comp.update_yaxes(
+                title_text='Composite Z-Score',
+                secondary_y=False,
+                title_font=dict(color="white"),
+                tickfont=dict(color="white"),
+                tickcolor="white",
+                gridcolor="rgba(255,255,255,0.10)",
+                zerolinecolor="rgba(255,255,255,0.15)",
+                linecolor="rgba(255,255,255,0.15)",
+                ticks="outside"
+            )
+            fig_comp.update_yaxes(
+                title_text='S&P 500 YoY %',
+                secondary_y=True,
+                range=[-80, 80],
+                title_font=dict(color="white"),
+                tickfont=dict(color="white"),
+                tickcolor="white"
+            )
+
+            st.plotly_chart(fig_comp, use_container_width=True)
+        except Exception:
+            st.error("Failed to render the composite chart.")
+
+        prog.progress(85, text="Computing interpretation...")
+
+        # Dynamic Interpretation (same logic as raw)
+        try:
+            phase_series    = pd.Series(phase, index=comp.index)
+            current_date    = phase_series.index[-1]
+            current_phase   = phase_series.iloc[-1]
+            current_comp    = comp_sm.loc[current_date]
+            current_slope   = slope.loc[current_date]
+            current_spx_yoy = spx_yoy.loc[current_date]
+
+            interp = ""
+            if current_phase == 'Early':
+                interp = (
+                    f"As of {current_date.date()}, the composite is {current_comp:.2f} "
+                    f"(+{current_slope:.3f} over {int(slope_window)}m) and S&P YoY is {current_spx_yoy:.1f}%. "
+                    "Early-phase conditions indicate nascent expansion. "
+                    "Leading activity indicators have bottomed and credit spreads are narrowing. "
+                    "Selective exposure to cyclical sectors may capture emerging growth while risks remain contained."
+                )
+            elif current_phase == 'Mid-Late':
+                interp = (
+                    f"As of {current_date.date()}, the composite stands at {current_comp:.2f} "
+                    f"(slope {current_slope:.3f}) with S&P YoY {current_spx_yoy:.1f}%. "
+                    "Mid-to-late cycle signals peak growth. "
+                    "Inflationary pressures and monetary tightening typically intensify in this phase. "
+                    "Shift allocation toward high-quality equities and defensive sectors to protect gains."
+                )
+            elif current_phase == 'Decline':
+                interp = (
+                    f"As of {current_date.date()}, the composite reads {current_comp:.2f} "
+                    f"(slope {current_slope:.3f}) and S&P YoY is {current_spx_yoy:.1f}%. "
+                    "Decline-phase patterns signal contraction. "
+                    "Risk sentiment deteriorates and liquidity tightens. "
+                    "Consider de-risking portfolios: increase fixed income, cash buffers, and low-volatility assets."
+                )
+            elif current_phase == 'Uncertain':
+                interp = (
+                    f"As of {current_date.date()}, the composite is neutral at {current_comp:.2f} "
+                    f"(slope {current_slope:.3f}) with S&P YoY {current_spx_yoy:.1f}%. "
+                    "Signals conflict and volatility often rises. "
+                    "Maintain balanced allocations, await clearer directional cues, and manage risk with disciplined stops."
+                )
+            else:
+                interp = "Phase classification unavailable."
+
+            with st.expander("Dynamic Interpretation", expanded=False):
+                st.write(interp)
+        except Exception:
+            st.error("Failed to produce the interpretation.")
+
+        # ================== SECTION 2 — RAW SERIES ==================
+        prog.progress(95, text="Rendering input grid...")
+
+        st.header("Macro Input Series (Resampled)")
+
+        with st.expander("Methodology", expanded=False):
+            st.write("Resample each series to the selected frequency (period end).")
+            st.latex(r"X^{(F)}_{t} = X_{\tau(t)} \quad \text{with } \tau(t) = \text{last timestamp in period } t")
+            st.write("Forward-fill missing observations to avoid gaps in aligned panels.")
+            st.latex(r"\tilde{X}_t = \begin{cases} X_t, & \text{if observed} \\ \tilde{X}_{t-1}, & \text{otherwise} \end{cases}")
+            st.write("No transforms are applied in this section. It is a clean view of inputs after resampling.")
+
+        try:
+            df_view = df.copy()
+            n_series = len(df_view.columns)
+            ncols = 3
+            nrows = math.ceil(n_series / ncols)
+
+            fig_grid = make_subplots(
+                rows=nrows, cols=ncols,
+                shared_xaxes=False,
+                subplot_titles=list(df_view.columns)
+            )
+
+            xmin, xmax = df_view.index.min(), df_view.index.max()
+            for i, col in enumerate(df_view.columns, start=1):
+                r = (i-1)//ncols + 1
+                c = (i-1)%ncols + 1
+                fig_grid.add_trace(
+                    go.Scatter(
+                        x=df_view.index, y=df_view[col],
+                        mode='lines',
+                        line=dict(width=1.5),
+                        name=col, showlegend=False
+                    ),
+                    row=r, col=c
+                )
+
+            for i in range(1, nrows*ncols + 1):
+                xaxis_key = f'xaxis{i}' if i > 1 else 'xaxis'
+                if xaxis_key in fig_grid.layout:
+                    fig_grid.layout[xaxis_key].update(
+                        range=[xmin, xmax],
+                        tickformat='%Y',
+                        tickfont=dict(color="white"),
+                        tickcolor="white"
+                    )
+
+            fig_grid.update_layout(
+                template='plotly_dark',
+                height=max(360, nrows*260),
+                title_text='All Input Series',
+                margin=dict(l=40, r=10, t=50, b=40),
+                paper_bgcolor='rgba(0,0,0,1)',
+                plot_bgcolor='rgba(0,0,0,1)',
+                font=dict(color='white')
+            )
+
+            for i in range(1, nrows*ncols + 1):
+                yaxis_key = f'yaxis{i}' if i > 1 else 'yaxis'
+                if yaxis_key in fig_grid.layout:
+                    fig_grid.layout[yaxis_key].update(
+                        tickfont=dict(color="white"),
+                        tickcolor="white"
+                    )
+
+            st.plotly_chart(fig_grid, use_container_width=True)
+        except Exception:
+            st.error("Failed to render the input grid.")
+
+        prog.progress(100, text="Done.")
+    except Exception:
+        st.error("Processing failed. Adjust parameters and try again.")
+else:
+    st.info("Set parameters in the sidebar and click **Run Analysis**.")
+
+
+# Hide default Streamlit style
+st.markdown(
+    """
+    <style>
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    </style>
+    """,
+    unsafe_allow_html=True
+)