Create requirements.txt

requirements.txt

@@ -0,0 +1,597 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import requests
+import numpy as np
+from datetime import datetime, date, timedelta
+import os
+
+st.set_page_config(layout="wide")
+
+FMP_API_KEY = os.getenv("FMP_API_KEY")
+
+# -----------------------------
+# Data Fetching
+# -----------------------------
+@st.cache_data
+def fetch_analyst_ratings(ticker):
+    """
+    Fetches analyst consensus ratings for a given ticker.
+    """
+    url = f'https://financialmodelingprep.com/api/v4/upgrades-downgrades-consensus?symbol={ticker}&apikey={API_KEY}'
+    try:
+        r = requests.get(url)
+        r.raise_for_status()
+        data = r.json()
+        return data[0] if data else None
+    except Exception:
+        return None
+
+@st.cache_data
+def fetch_detailed_ratings(ticker):
+    """
+    Fetches detailed analyst ratings for a given ticker.
+    """
+    url = f'https://financialmodelingprep.com/api/v4/upgrades-downgrades?symbol={ticker}&apikey={API_KEY}'
+    try:
+        r = requests.get(url)
+        r.raise_for_status()
+        data = r.json()
+        df = pd.DataFrame(data) if data else pd.DataFrame()
+        # Reorder columns if target columns exist
+        if not df.empty and any(col in df.columns for col in ['newsBaseURL', 'newsPublisher', 'newsURL', 'newsTitle']):
+            target_cols = ['newsBaseURL', 'newsPublisher', 'newsURL', 'newsTitle']
+            other_cols = [c for c in df.columns if c not in target_cols]
+            new_order = other_cols + target_cols
+            df = df[new_order]
+        return df
+    except Exception:
+        return pd.DataFrame()
+
+@st.cache_data
+def fetch_upgrades_downgrades_rss_feed(api_key, num_pages=5):
+    """
+    Fetches up to 'num_pages' pages of upgrades/downgrades data
+    from the FMP RSS feed API.
+    """
+    all_data = []
+    for page in range(num_pages):
+        url = f"https://financialmodelingprep.com/api/v4/upgrades-downgrades-rss-feed?page={page}&apikey={api_key}"
+        response = requests.get(url)
+        if response.status_code == 200:
+            data = response.json()
+            all_data.extend(data)
+        else:
+            print(f"Error fetching page {page}: {response.status_code}")
+    df = pd.DataFrame(all_data)
+    if not df.empty and any(col in df.columns for col in ['newsBaseURL', 'newsPublisher', 'newsURL', 'newsTitle']):
+        target_cols = ['newsBaseURL', 'newsPublisher', 'newsURL', 'newsTitle']
+        other_cols = [c for c in df.columns if c not in target_cols]
+        new_order = other_cols + target_cols
+        df = df[new_order]
+    return df
+
+# -----------------------------
+# Plotting
+# -----------------------------
+def plot_analyst_ratings(data):
+    """
+    Plots a horizontal bar chart of analyst consensus ratings.
+    """
+    df = pd.DataFrame({
+        "rating": ["Strong Buy", "Buy", "Hold", "Sell", "Strong Sell"],
+        "count": [
+            data["strongBuy"], data["buy"], data["hold"], data["sell"], data["strongSell"]
+        ]
+    })
+    total_ratings = df["count"].sum()
+    df["percentage"] = (df["count"] / total_ratings * 100).round(0).astype(int)
+    df["text"] = df["count"].astype(str) + " (" + df["percentage"].astype(str) + "%)"
+
+    color_map = {
+        "Strong Buy": "#145A32",
+        "Buy": "#27ae60",
+        "Hold": "#f1c40f",
+        "Sell": "#e74c3c",
+        "Strong Sell": "#641E16"
+    }
+    custom_colors = [color_map[r] for r in df["rating"]]
+
+    fig = px.bar(
+        df,
+        x='count',
+        y='rating',
+        orientation='h',
+        color='rating',
+        color_discrete_sequence=custom_colors,
+        text='text'
+    )
+    fig.update_traces(
+        textposition='outside',
+        textfont=dict(size=16, color="white"),
+        textangle=0
+    )
+    fig.update_layout(
+        template='plotly_dark',
+        paper_bgcolor='#0e1117',
+        plot_bgcolor='#0e1117',
+        showlegend=False,
+        xaxis=dict(showgrid=False, visible=False),
+        yaxis=dict(title='', showgrid=False, tickfont=dict(size=18, color="white")),
+        margin=dict(l=120, r=10, t=80, b=30),
+        height=350,
+        title=dict(
+            text=(
+                f"Analyst Consensus: {data['consensus']}<br>"
+                f"<span style='font-size:0.8em;color:white'>Aggregate opinion from {total_ratings} analysts</span>"
+            ),
+            x=0.015,
+            xanchor='left',
+            y=0.9,
+            yanchor='top',
+            font=dict(size=25, color="white")
+        ),
+        width=None
+    )
+    return fig
+
+def plot_sentiment_over_time(df):
+    """
+    Plots net sentiment changes over time.
+    """
+    df['publishedDate'] = pd.to_datetime(df['publishedDate'], errors='coerce')
+    grade_map = {
+        'Strong Buy': 2, 'Buy': 2, 'Overweight': 2, 'Outperform': 2,
+        'Hold': 0, 'Neutral': 0,
+        'Underperform': -2, 'Reduce': -2, 'Sell': -2
+    }
+    df['newGrade_score'] = df['newGrade'].map(grade_map)
+    df['previousGrade_score'] = df['previousGrade'].map(grade_map)
+    df['sentiment_change'] = df['newGrade_score'] - df['previousGrade_score']
+    df['year_month'] = df['publishedDate'].dt.to_period('M')
+
+    monthly_sentiment = df.groupby('year_month')['sentiment_change'].sum().reset_index()
+    monthly_sentiment['year_month'] = monthly_sentiment['year_month'].astype(str)
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(
+        x=monthly_sentiment['year_month'],
+        y=monthly_sentiment['sentiment_change'],
+        mode='lines+markers',
+        name='Net Sentiment',
+        line=dict(color='blue', width=6),
+        marker=dict(color='blue', size=8),
+        hovertemplate='Month: %{x}<br>Sentiment: %{y}<extra></extra>'
+    ))
+    fig.update_layout(
+        template='plotly_dark',
+        paper_bgcolor='#0e1117',
+        plot_bgcolor='#0e1117',
+        #title="Analyst Sentiment Over Time",
+        xaxis=dict(
+            title=dict(text='Month', font=dict(color='green', size=20)),
+            tickangle=45,
+            tickfont=dict(color='white'),
+            showgrid=True,
+            gridcolor='white'
+        ),
+        yaxis=dict(
+            title=dict(text='Sum of Sentiment Changes', font=dict(color='green', size=20)),
+            tickfont=dict(color='white'),
+            showgrid=True,
+            gridcolor='white'
+        ),
+        font=dict(color='white'),
+        margin=dict(l=40, r=40, t=80, b=80),
+        width=None
+    )
+    return fig
+
+def plot_actions_over_time(df):
+    """
+    Plots a stacked bar chart of analyst actions over time.
+    """
+    df['publishedDate'] = pd.to_datetime(df['publishedDate'])
+    df['year_month'] = df['publishedDate'].dt.to_period('M')
+    monthly_counts = df.groupby(['year_month','action'])['symbol'].count().reset_index(name='count')
+    monthly_counts['year_month'] = monthly_counts['year_month'].astype(str)
+
+    pivot_df = monthly_counts.pivot(
+        index='year_month',
+        columns='action',
+        values='count'
+    ).fillna(0)
+
+    action_colors = {
+        'upgrade': 'green',
+        'downgrade': 'red',
+        'hold': 'gray',
+        'initiate': 'orange'
+    }
+    fig = go.Figure()
+    for action in sorted(pivot_df.columns):
+        fig.add_trace(go.Bar(
+            x=pivot_df.index,
+            y=pivot_df[action],
+            name=action.capitalize(),
+            marker_color=action_colors.get(action, 'blue'),
+            hovertemplate=(
+                "<b>%{x}</b><br>Action: " + action.capitalize() + "<br>Count: %{y}<extra></extra>"
+            )
+        ))
+    fig.update_layout(
+        barmode='stack',
+        template='plotly_dark',
+        paper_bgcolor='#0e1117',
+        plot_bgcolor='#0e1117',
+        #title="Upgrades vs. Downgrades vs. Holds Over Time",
+        xaxis=dict(
+            title=dict(text='Month', font=dict(color='green', size=20)),
+            tickangle=45,
+            tickfont=dict(color='white'),
+            showgrid=True,
+            gridcolor='white'
+        ),
+        yaxis=dict(
+            title=dict(text='Count of Actions', font=dict(color='green', size=20)),
+            tickfont=dict(color='white'),
+            showgrid=True,
+            gridcolor='white'
+        ),
+        legend=dict(font=dict(color='white')),
+        margin=dict(l=40, r=40, t=80, b=80),
+        width=None
+    )
+    return fig
+
+def plot_animated_transition_heatmap(df):
+    """
+    Plots an animated heatmap of grade transitions over time.
+    """
+    df['publishedDate'] = pd.to_datetime(df['publishedDate'], errors='coerce')
+    df['year_month'] = df['publishedDate'].dt.to_period('M')
+    all_months = sorted(df['year_month'].dropna().unique())
+
+    all_prev_grades = sorted(df['previousGrade'].dropna().unique())
+    all_new_grades = sorted(df['newGrade'].dropna().unique())
+
+    frames = []
+    initial_data = None
+
+    for idx, month in enumerate(all_months):
+        monthly_df = df[df['year_month'] == month]
+        transition_counts = monthly_df.groupby(
+            ['previousGrade','newGrade']
+        ).size().reset_index(name='count')
+
+        z_data = np.zeros((len(all_prev_grades), len(all_new_grades)), dtype=int)
+        for _, row in transition_counts.iterrows():
+            r_idx = all_prev_grades.index(row['previousGrade'])
+            c_idx = all_new_grades.index(row['newGrade'])
+            z_data[r_idx, c_idx] = row['count']
+
+        z_data_list = z_data.tolist()
+        frames.append(
+            go.Frame(
+                data=[go.Heatmap(
+                    z=z_data_list,
+                    coloraxis="coloraxis",
+                    hovertemplate="Prev: %{y}<br>New: %{x}<br>Count: %{z}<extra></extra>",
+                    text=z_data_list,
+                    texttemplate="%{text}",
+                    textfont=dict(color="white"),
+                    showscale=True
+                )],
+                name=str(month)
+            )
+        )
+        if idx == 0:
+            initial_data = z_data_list
+
+    if initial_data is None:
+        raise ValueError("No valid data found to plot.")
+
+    fig = go.Figure(
+        data=[go.Heatmap(
+            z=initial_data,
+            coloraxis="coloraxis",
+            hovertemplate="Prev: %{y}<br>New: %{x}<br>Count: %{z}<extra></extra>",
+            text=initial_data,
+            texttemplate="%{text}",
+            textfont=dict(color="white"),
+            showscale=True
+        )],
+        layout=go.Layout(
+            # title="Animated Transition Heatmap (Monthly)",
+            xaxis=dict(
+                title=dict(text="New Grade", font=dict(color="green", size=20), standoff=75),
+                tickvals=list(range(len(all_new_grades))),
+                ticktext=all_new_grades,
+                tickfont=dict(color='white')
+            ),
+            yaxis=dict(
+                title=dict(text="Previous Grade", font=dict(color="green", size=20)),
+                tickvals=list(range(len(all_prev_grades))),
+                ticktext=all_prev_grades,
+                tickfont=dict(color='white'),
+                autorange='reversed'
+            ),
+            template="plotly_dark",
+            paper_bgcolor='#0e1117',
+            plot_bgcolor='#0e1117'
+        ),
+        frames=frames
+    )
+
+    fig.update_layout(
+        coloraxis=dict(colorscale="Blues"),
+        updatemenus=[
+            dict(
+                type="buttons",
+                showactive=False,
+                x=0,            # Position from left
+                y=1.2,          # Position from top
+                xanchor="left", # Anchor the button's left side to x=0
+                yanchor="top",  # Anchor the button's top to y=1
+                buttons=[
+                    dict(
+                        label="Play Animation",
+                        method="animate",
+                        args=[
+                            None,
+                            {"frame": {"duration": 1000, "redraw": True},
+                             "transition": {"duration": 500}}
+                        ]
+                    )
+                ]
+            )
+        ],
+        sliders=[
+            dict(
+                steps=[
+                    dict(
+                        method="animate",
+                        args=[
+                            [frame.name],
+                            {
+                                "mode": "immediate",
+                                "frame": {"duration": 500, "redraw": True},
+                                "transition": {"duration": 300}
+                            }
+                        ],
+                        label=frame.name
+                    )
+                    for frame in frames
+                ],
+                x=0,
+                y=-0.1,
+                xanchor="left",
+                yanchor="top",
+                pad=dict(b=50, t=20),
+                currentvalue=dict(prefix="Month: ", font=dict(color='white')),
+                len=0.9
+            )
+        ],
+        width=None
+    )
+    return fig
+
+def plot_extreme_sentiment_symbols(
+    df,
+    start_date=None,
+    end_date=None,
+    top_n=10,
+    title= ""
+):
+    """
+    Identifies most bullish and bearish symbols based on sentiment changes.
+    """
+    df['publishedDate'] = pd.to_datetime(df['publishedDate'], errors='coerce')
+    df['publishedDate'] = df['publishedDate'].dt.tz_localize(None)
+
+    if start_date is not None:
+        df = df[df['publishedDate'] >= pd.to_datetime(start_date)]
+    if end_date is not None:
+        df = df[df['publishedDate'] <= pd.to_datetime(end_date)]
+
+    grade_map = {
+        'Strong Buy': 2, 'Buy': 2, 'Overweight': 2, 'Outperform': 2,
+        'Hold': 0, 'Neutral': 0,
+        'Underperform': -2, 'Reduce': -2, 'Sell': -2
+    }
+    df['newGrade_score'] = df['newGrade'].map(grade_map)
+    df['previousGrade_score'] = df['previousGrade'].map(grade_map)
+    df['sentiment_change'] = df['newGrade_score'] - df['previousGrade_score']
+
+    symbol_sentiment = df.groupby('symbol')['sentiment_change'].sum().reset_index()
+    symbol_sentiment.sort_values('sentiment_change', ascending=False, inplace=True)
+
+    top_bullish = symbol_sentiment.head(top_n)
+    top_bearish = symbol_sentiment.tail(top_n)
+
+    top_bullish['category'] = 'Bullish'
+    top_bearish['category'] = 'Bearish'
+    combined = pd.concat([top_bullish, top_bearish], ignore_index=True)
+
+    fig = px.bar(
+        combined,
+        x='sentiment_change',
+        y='symbol',
+        color='category',
+        orientation='h',
+        title=title,
+        text='sentiment_change',
+        color_discrete_map={'Bullish': 'green', 'Bearish': 'red'}
+    )
+    n_bars = len(combined)
+    fig.update_layout(
+        height=50 + (40 * n_bars),
+        template='plotly_dark',
+        paper_bgcolor='#0e1117',
+        plot_bgcolor='#0e1117',
+        xaxis=dict(
+            title=dict(text='Net Sentiment (Sum of Upgrades/Downgrades)', font=dict(color='green', size=20)),
+            tickfont=dict(color='white')
+        ),
+        yaxis=dict(
+            title=dict(text='Symbol', font=dict(color='green', size=20)),
+            dtick=1,
+            tickfont=dict(color='white')
+        ),
+        width=None
+    )
+    fig.update_traces(textposition='auto')
+    return fig
+
+# -----------------------------
+# Sidebar and Pages
+# -----------------------------
+with st.sidebar:
+    st.header("Parameters")
+    with st.expander("Select Page", expanded=True):
+        page = st.radio("Analyses", ["Actions by Ticker", "Actions Live Feed"], index=0)
+
+    if page == "Actions by Ticker":
+        with st.expander("Ticker Input", expanded=True):
+            ticker = st.text_input(
+                "Enter Ticker Symbol",
+                value="AAPL",
+                help="Enter a valid stock ticker symbol (e.g., AAPL)."
+            )
+        run_button = st.button("Run Analysis")
+
+    else:
+        with st.expander("Date Range", expanded=True):
+            # In the sidebar for live feed:
+            start_date = st.date_input(
+                "Start Date",
+                value=date.today() - timedelta(days=45),
+                help="Select the start date."
+            )
+            end_date = st.date_input(
+                "End Date",
+                value=date.today(),
+                help="Select the end date."
+            )
+        with st.expander("Display Options", expanded=True):
+            top_n = st.slider(
+                "Number of Symbols",
+                min_value=5,
+                max_value=20,
+                value=10,
+                help="How many bullish and bearish symbols to display."
+            )
+        run_button = st.button("Run Analysis")
+
+st.title("Stock Downgrades and Upgrades")
+st.write("This tool provides real-time updates on analyst ratings, shows sentiment trends over time, and displays recent analyst actions.")
+
+if 'results' not in st.session_state:
+    st.session_state.results = {}
+
+# -----------------------------
+# Page 1: Actions by Ticker
+# -----------------------------
+if page == "Actions by Ticker":
+    if run_button:
+        if not ticker.strip():
+            st.error("Please enter a valid ticker symbol.")
+        else:
+            with st.spinner("Fetching data..."):
+                consensus_data = fetch_analyst_ratings(ticker.upper())
+                detailed_data = fetch_detailed_ratings(ticker.upper())
+                st.session_state.results["consensus"] = consensus_data
+                st.session_state.results["detailed"] = detailed_data
+
+    if "consensus" in st.session_state.results and "detailed" in st.session_state.results:
+        consensus_data = st.session_state.results["consensus"]
+        detailed_data = st.session_state.results["detailed"]
+
+        st.subheader(f"Analyst Consensus for {ticker.upper()}")
+        st.write("This chart displays the overall analyst consensus rating for the stock. It shows the distribution of ratings such as Strong Buy, Buy, Hold, Sell, and Strong Sell.")
+        if consensus_data:
+            st.plotly_chart(plot_analyst_ratings(consensus_data), use_container_width=True)
+        else:
+            st.warning("No consensus data available.")
+
+        st.subheader(f"Sentiment Trend Over Time for {ticker.upper()}")
+        st.write("This line chart tracks changes in analyst sentiment over time. Net sentiment is computed by subtracting the previous rating score from the new rating score using a mapping (Strong Buy, Buy, Overweight, Outperform = 2; Hold, Neutral = 0; Underperform, Reduce, Sell = -2), which indicates the direction of rating adjustments each month.")
+        if not detailed_data.empty:
+            st.plotly_chart(plot_sentiment_over_time(detailed_data), use_container_width=True)
+        else:
+            st.warning("No detailed data available for sentiment analysis.")
+
+        st.subheader(f"Analyst Actions Over Time for {ticker.upper()}")
+        st.write("This stacked bar chart shows monthly counts of analyst actions. It shows the number of upgrades, downgrades, and holds over time.")
+        if not detailed_data.empty:
+            st.plotly_chart(plot_actions_over_time(detailed_data), use_container_width=True)
+        else:
+            st.warning("No detailed data available for action analysis.")
+
+        st.subheader(f"Rating Transition Heatmap for {ticker.upper()}")
+        st.write("This animated heatmap visualizes transitions between previous and new analyst ratings each month. It shows how frequently ratings change from one category to another. Use the slider or play button to observe changes for specific dates.")
+        if not detailed_data.empty:
+            try:
+                st.plotly_chart(plot_animated_transition_heatmap(detailed_data), use_container_width=True)
+            except ValueError:
+                st.warning("Insufficient data for transition heatmap.")
+        else:
+            st.warning("No detailed data available for transitions.")
+
+        st.subheader(f"Detailed Analyst Action Data for {ticker.upper()}")
+        st.write("The table below provides the detailed information on each analyst action and the associated news data.")
+        if not detailed_data.empty:
+            with st.expander("View Detailed Results", expanded=False):
+                st.dataframe(detailed_data)
+        else:
+            st.warning("No detailed data available.")
+
+# -----------------------------
+# Page 2: Actions Live Feed
+# -----------------------------
+else:
+    if run_button:
+        if start_date > end_date:
+            st.error("Start date must be before end date.")
+        else:
+            with st.spinner("Fetching live feed data..."):
+                rss_feed_df = fetch_upgrades_downgrades_rss_feed(API_KEY, num_pages=5)
+                st.session_state.results["live_data"] = rss_feed_df
+
+    if "live_data" in st.session_state.results:
+        live_data = st.session_state.results["live_data"]
+        if not live_data.empty:
+            st.subheader("Top Bullish and Bearish Stocks")
+            st.write("This bar chart displays stocks with the highest net sentiment. Net sentiment is computed by subtracting previous rating scores from new rating scores using a defined mapping (e.g., Strong Buy, Buy, Overweight, Outperform = +2; Hold, Neutral = 0; Underperform, Reduce, Sell = -2). This helps identify stocks viewed most positively and negatively by analysts.")
+            st.plotly_chart(
+                plot_extreme_sentiment_symbols(
+                    live_data,
+                    start_date=start_date,
+                    end_date=end_date,
+                    top_n=top_n
+                ),
+                use_container_width=True
+            )
+
+            st.subheader("Detailed Live Feed Data")
+            st.write("This table provides a detailed view of the latest analyst upgrades, downgrades, and related news.")
+            with st.expander("View Detailed Results", expanded=False):
+                st.dataframe(live_data)
+        else:
+            st.warning("No live data returned from the feed.")
+    else:
+        st.info("Please run the analysis to fetch live data.")
+        
+        
+
+# Hide default Streamlit style
+st.markdown(
+    """
+    <style>
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    </style>
+    """,
+    unsafe_allow_html=True
+)