Update app.py

app.py

@@ -1,105 +1,133 @@
-import streamlit as st
+import os
 import datetime
 import requests
 import pandas as pd
+import streamlit as st
 from streamlit_calendar import calendar
-import os
 
 API_KEY = os.getenv("FMP_API_KEY")
 
-def parse_time_field(date_str, time_str):
+# ---------- Utilities ----------
+
+def _normalize_date(date_val):
+    """Return YYYY-MM-DD or None if invalid."""
+    if isinstance(date_val, datetime.datetime):
+        return date_val.date().strftime("%Y-%m-%d")
+    if isinstance(date_val, datetime.date):
+        return date_val.strftime("%Y-%m-%d")
+    if isinstance(date_val, str):
+        s = date_val.strip()
+        if not s:
+            return None
+        # handle strings like "2025-08-18 00:00:00"
+        if len(s) >= 10:
+            return s[:10]
+    return None
+
+def parse_time_field(date_val, time_val):
     """
-    Convert a date string plus partial time info into date-time strings.
-    Example: date='2023-08-17', time='pre market' -> '2023-08-17T07:00:00'
+    Convert an input date plus a 'time' label into ISO start/end strings.
+    Handles None/missing time safely. Returns (start_iso, end_iso) or (None, None) if date invalid.
     """
-    if time_str and ":" in time_str:
-        return f"{date_str}T{time_str}:00", f"{date_str}T{time_str}:00"
+    date_str = _normalize_date(date_val)
+    if not date_str:
+        return None, None
+
+    t = (time_val or "").strip().lower()
+
+    # If a clock time is provided (e.g., "09:30" or "09:30:00")
+    if ":" in t:
+        # normalize to HH:MM:SS if we can
+        parts = t.split(":")
+        if len(parts) == 2:
+            t = f"{t}:00"
+        elif len(parts) >= 3:
+            t = ":".join(parts[:3])
+        else:
+            t = "00:00:00"
+        chosen = t
     else:
+        # Common labels from FMP (and synonyms)
         time_map = {
-            "bmo": "06:00:00",
-            "amc": "18:00:00",
-            "pre market": "07:00:00",
-            "post market": "16:00:00",
+            "bmo": "06:00:00", "before market": "06:00:00", "pre-market": "06:00:00",
+            "pre market": "07:00:00",  # keep your original mapping too
+            "amc": "18:00:00", "after market": "18:00:00", "post-market": "18:00:00",
+            "post market": "16:00:00",  # keep original
             "during market": "10:00:00",
         }
-        chosen_time = time_map.get(time_str.lower(), "00:00:00")
-        return f"{date_str}T{chosen_time}", f"{date_str}T{chosen_time}"
+        chosen = time_map.get(t, "00:00:00")
+
+    start_iso = f"{date_str}T{chosen}"
+    end_iso   = f"{date_str}T{chosen}"
+    return start_iso, end_iso
+
+# ---------- API calls ----------
 
 def fetch_earnings(from_date, to_date, limit):
     url = (
-        f"https://financialmodelingprep.com/api/v4/earning-calendar-confirmed"
-        f"?from={from_date}&to={to_date}&limit={limit}&apikey={API_KEY}"
+        "https://financialmodelingprep.com/api/v4/earning-calendar-confirmed"
+        f"?from={_normalize_date(from_date)}&to={_normalize_date(to_date)}&limit={int(limit)}&apikey={API_KEY}"
     )
-    resp = requests.get(url)
-    if resp.status_code == 200:
-        return resp.json()
-    return []
+    r = requests.get(url)
+    return r.json() if r.status_code == 200 else []
 
 def fetch_dividends(from_date, to_date):
     url = (
-        f"https://financialmodelingprep.com/api/v3/stock_dividend_calendar"
-        f"?from={from_date}&to={to_date}&apikey={API_KEY}"
+        "https://financialmodelingprep.com/api/v3/stock_dividend_calendar"
+        f"?from={_normalize_date(from_date)}&to={_normalize_date(to_date)}&apikey={API_KEY}"
     )
-    resp = requests.get(url)
-    if resp.status_code == 200:
-        return resp.json()
-    return []
+    r = requests.get(url)
+    return r.json() if r.status_code == 200 else []
 
 def fetch_splits(from_date, to_date):
     url = (
-        f"https://financialmodelingprep.com/api/v3/stock_split_calendar"
-        f"?from={from_date}&to={to_date}&apikey={API_KEY}"
+        "https://financialmodelingprep.com/api/v3/stock_split_calendar"
+        f"?from={_normalize_date(from_date)}&to={_normalize_date(to_date)}&apikey={API_KEY}"
     )
-    resp = requests.get(url)
-    if resp.status_code == 200:
-        return resp.json()
-    return []
+    r = requests.get(url)
+    return r.json() if r.status_code == 200 else []
 
 def fetch_earnings_ticker(symbol, limit):
     url = (
-        f"https://financialmodelingprep.com/api/v3/historical/earning_calendar/"
-        f"{symbol}?limit={limit}&apikey={API_KEY}"
+        "https://financialmodelingprep.com/api/v3/historical/earning_calendar/"
+        f"{symbol}?limit={int(limit)}&apikey={API_KEY}"
     )
-    resp = requests.get(url)
-    if resp.status_code == 200:
-        return resp.json()
-    return []
+    r = requests.get(url)
+    return r.json() if r.status_code == 200 else []
 
 def fetch_dividends_ticker(symbol):
     url = (
-        f"https://financialmodelingprep.com/api/v3/historical-price-full/stock_dividend/"
+        "https://financialmodelingprep.com/api/v3/historical-price-full/stock_dividend/"
         f"{symbol}?apikey={API_KEY}"
     )
-    resp = requests.get(url)
-    if resp.status_code == 200:
-        return resp.json()
-    return {}
+    r = requests.get(url)
+    return r.json() if r.status_code == 200 else {}
 
 def fetch_splits_ticker(symbol):
     url = (
-        f"https://financialmodelingprep.com/api/v3/historical-price-full/stock_split/"
+        "https://financialmodelingprep.com/api/v3/historical-price-full/stock_split/"
         f"{symbol}?apikey={API_KEY}"
     )
-    resp = requests.get(url)
-    if resp.status_code == 200:
-        return resp.json()
-    return {}
+    r = requests.get(url)
+    return r.json() if r.status_code == 200 else {}
+
+# ---------- App ----------
 
 def main():
-    # Updated title to reflect more events
     st.set_page_config(page_title="Earnings, Dividends, and Splits Calendar", layout="wide")
 
-    # Initialize session state
+    if not API_KEY:
+        st.warning("FMP_API_KEY is not set. Please add it in your Space secrets.")
+
     if "general_data" not in st.session_state:
         st.session_state["general_data"] = []
     if "ticker_data" not in st.session_state:
         st.session_state["ticker_data"] = []
 
     st.title("Corporate Events Calendar")
-    st.write("This calendar shows earnings, dividends, and stock splits. Set parameters and click run. ")
+    st.write("This calendar shows earnings, dividends, and stock splits. Set parameters and click run.")
 
     st.sidebar.title("Input Parameters")
-    
     with st.sidebar.expander("How to Use", expanded=False):
         st.write(
             """
@@ -113,77 +141,71 @@ def main():
     with st.sidebar.expander("", expanded=True):
         page_choice = st.radio("Page", ["General Calendar", "Ticker Calendar"])
 
-    # Default date range
     today = datetime.date.today()
     one_month_later = today + datetime.timedelta(days=30)
 
     if page_choice == "General Calendar":
         with st.sidebar.expander("Event Type", expanded=True):
-            include_earnings = st.checkbox("Include Earnings", value=True, help="If checked, will fetch earnings within the date range.")
-            include_dividends = st.checkbox("Include Dividends", value=True, help="If checked, will fetch dividends within the date range.")
-            include_splits = st.checkbox("Include Stock Splits", value=True, help="If checked, will fetch stock splits within the date range.")
+            include_earnings = st.checkbox("Include Earnings", value=True)
+            include_dividends = st.checkbox("Include Dividends", value=True)
+            include_splits = st.checkbox("Include Stock Splits", value=True)
 
         with st.sidebar.expander("Parameters", expanded=True):
-            from_date = st.date_input("From Date", value=today, help="Start date range")
-            to_date = st.date_input("To Date", value=one_month_later, help="End date range")
-            limit_val = st.number_input("Limit", value=200, help="Number of earnings records to retrieve")
+            from_date = st.date_input("From Date", value=today)
+            to_date = st.date_input("To Date", value=one_month_later)
+            limit_val = st.number_input("Limit", value=200, min_value=1)
 
         if st.sidebar.button("Retrieve Calendar", key="fetch_general"):
-            # Collect everything in one list
             all_events = []
 
             if include_earnings:
-                earnings_data = fetch_earnings(from_date, to_date, limit_val)
-                for item in earnings_data:
-                    date_str = item.get("date", "")
-                    time_str = item.get("time", "")
-                    start_dt, end_dt = parse_time_field(date_str, time_str)
+                for item in fetch_earnings(from_date, to_date, limit_val):
+                    date_raw = item.get("date")
+                    if not _normalize_date(date_raw):
+                        continue  # skip invalid date
+                    time_raw = item.get("time")
+                    start_dt, end_dt = parse_time_field(date_raw, time_raw)
+                    if not start_dt:
+                        continue
                     sym = item.get("symbol", "")
-                    event_title = f"[Earnings] {sym}"
-                    # Store entire item plus fields for the calendar
                     event_entry = {
                         "start": start_dt,
                         "end": end_dt,
-                        "title": event_title,
+                        "title": f"[Earnings] {sym}",
                         "color": "#3D9DF3",
-                        "eventType": "Earnings"
+                        "eventType": "Earnings",
                     }
-                    # Merge item fields directly
                     event_entry.update(item)
                     all_events.append(event_entry)
 
             if include_dividends:
-                div_data = fetch_dividends(from_date, to_date)
-                for item in div_data:
-                    date_str = item.get("date", "")
-                    start_dt = f"{date_str}T00:00:00"
-                    end_dt = f"{date_str}T23:59:59"
-                    sym = item.get("symbol", "")
-                    event_title = f"[Dividend] {sym}"
+                for item in fetch_dividends(from_date, to_date):
+                    date_raw = item.get("date")
+                    d = _normalize_date(date_raw)
+                    if not d:
+                        continue
                     event_entry = {
-                        "start": start_dt,
-                        "end": end_dt,
-                        "title": event_title,
+                        "start": f"{d}T00:00:00",
+                        "end": f"{d}T23:59:59",
+                        "title": f"[Dividend] {item.get('symbol','')}",
                         "color": "#80C080",
-                        "eventType": "Dividend"
+                        "eventType": "Dividend",
                     }
                     event_entry.update(item)
                     all_events.append(event_entry)
 
             if include_splits:
-                split_data = fetch_splits(from_date, to_date)
-                for item in split_data:
-                    date_str = item.get("date", "")
-                    start_dt = f"{date_str}T00:00:00"
-                    end_dt = f"{date_str}T23:59:59"
-                    sym = item.get("symbol", "")
-                    event_title = f"[Split] {sym}"
+                for item in fetch_splits(from_date, to_date):
+                    date_raw = item.get("date")
+                    d = _normalize_date(date_raw)
+                    if not d:
+                        continue
                     event_entry = {
-                        "start": start_dt,
-                        "end": end_dt,
-                        "title": event_title,
+                        "start": f"{d}T00:00:00",
+                        "end": f"{d}T23:59:59",
+                        "title": f"[Split] {item.get('symbol','')}",
                         "color": "#FFC870",
-                        "eventType": "Split"
+                        "eventType": "Split",
                     }
                     event_entry.update(item)
                     all_events.append(event_entry)
@@ -191,20 +213,12 @@ def main():
             st.session_state["general_data"] = all_events
 
         st.subheader("General Calendar Results")
-
         data_general = st.session_state["general_data"]
         if data_general:
-            # Prepare events for calendar
-            calendar_events = []
-            for ev in data_general:
-                event_for_cal = {
-                    "title": ev["title"],
-                    "start": ev["start"],
-                    "end": ev["end"],
-                    "color": ev["color"],
-                }
-                calendar_events.append(event_for_cal)
-
+            calendar_events = [
+                {"title": ev["title"], "start": ev["start"], "end": ev["end"], "color": ev["color"]}
+                for ev in data_general
+            ]
             cal_options = {
                 "initialView": "dayGridMonth",
                 "headerToolbar": {
@@ -214,83 +228,72 @@ def main():
                 },
                 "navLinks": True,
             }
-
-            # Show calendar
             calendar(events=calendar_events, options=cal_options, key="general_cal")
-
-            # Show entire dataframe
             st.write("Data Table")
-            df_g = pd.DataFrame(data_general)
-            st.dataframe(df_g, use_container_width=True)
+            st.dataframe(pd.DataFrame(data_general), use_container_width=True)
         else:
             st.write("No data retrieved. Select event types and click the button.")
 
     else:
-    
         with st.sidebar.expander("Event Type", expanded=True):
-        # Ticker Calendar
-            include_earnings_t = st.checkbox("Include Earnings", value=True, help="If checked, will fetch historical earnings data.")
-            include_dividends_t = st.checkbox("Include Dividends", value=True, help="If checked, will fetch historical dividends data.")
-            include_splits_t = st.checkbox("Include Splits", value=True, help="If checked, will fetch historical stock splits data.")
-            
+            include_earnings_t = st.checkbox("Include Earnings", value=True)
+            include_dividends_t = st.checkbox("Include Dividends", value=True)
+            include_splits_t = st.checkbox("Include Splits", value=True)
+
         with st.sidebar.expander("Parameters", expanded=True):
-            symbol = st.text_input("Symbol", value="AAPL", help="Enter a stock ticker")
-            limit_val_ticker = st.number_input("Limit", value=50, help="Number of earnings records to retrieve")
+            symbol = st.text_input("Symbol", value="AAPL")
+            limit_val_ticker = st.number_input("Limit", value=50, min_value=1)
 
         if st.sidebar.button("Retrieve Ticker Calendar", key="fetch_ticker"):
             ticker_events = []
 
             if include_earnings_t:
-                data_earnings_t = fetch_earnings_ticker(symbol, limit_val_ticker)
-                for item in data_earnings_t:
-                    date_str = item.get("date", "")
-                    time_str = item.get("time", "")
-                    start_dt, end_dt = parse_time_field(date_str, time_str)
-                    event_title = f"[Earnings] {symbol}"
+                for item in fetch_earnings_ticker(symbol, limit_val_ticker):
+                    date_raw = item.get("date")
+                    if not _normalize_date(date_raw):
+                        continue
+                    time_raw = item.get("time")
+                    start_dt, end_dt = parse_time_field(date_raw, time_raw)
+                    if not start_dt:
+                        continue
                     event_info = {
                         "start": start_dt,
                         "end": end_dt,
-                        "title": event_title,
+                        "title": f"[Earnings] {symbol}",
                         "color": "#3D9DF3",
-                        "eventType": "Earnings"
+                        "eventType": "Earnings",
                     }
                     event_info.update(item)
                     ticker_events.append(event_info)
 
             if include_dividends_t:
-                data_div_t = fetch_dividends_ticker(symbol)
-                # The response is a dict with keys like "symbol" and "historical"
-                historical_divs = data_div_t.get("historical", [])
-                for item in historical_divs:
-                    date_str = item.get("date", "")
-                    start_dt = f"{date_str}T00:00:00"
-                    end_dt = f"{date_str}T23:59:59"
-                    event_title = f"[Dividend] {symbol}"
+                hist = fetch_dividends_ticker(symbol).get("historical", [])
+                for item in hist:
+                    d = _normalize_date(item.get("date"))
+                    if not d:
+                        continue
                     event_info = {
-                        "start": start_dt,
-                        "end": end_dt,
-                        "title": event_title,
+                        "start": f"{d}T00:00:00",
+                        "end": f"{d}T23:59:59",
+                        "title": f"[Dividend] {symbol}",
                         "color": "#80C080",
-                        "eventType": "Dividend"
+                        "eventType": "Dividend",
                     }
                     event_info.update(item)
                     ticker_events.append(event_info)
 
             if include_splits_t:
-                data_split_t = fetch_splits_ticker(symbol)
-                # The response is a dict with keys like "symbol" and "historical"
-                historical_splits = data_split_t.get("historical", [])
-                for item in historical_splits:
-                    date_str = item.get("date", "")
-                    start_dt = f"{date_str}T00:00:00"
-                    end_dt = f"{date_str}T23:59:59"
-                    event_title = f"[Split] {symbol}"
+                hist = fetch_splits_ticker(symbol).get("historical", [])
+                for item in hist:
+                    d = _normalize_date(item.get("date"))
+                    if not d:
+                        continue
                     event_info = {
-                        "start": start_dt,
-                        "end": end_dt,
-                        "title": event_title,
+                        "start": f"{d}T00:00:00",
+                        "end": f"{d}T23:59:59",
+                        "title": f"[Split] {symbol}",
                         "color": "#FFC870",
-                        "eventType": "Split"
+                        "eventType": "Split",
                     }
                     event_info.update(item)
                     ticker_events.append(event_info)
@@ -298,19 +301,12 @@ def main():
             st.session_state["ticker_data"] = ticker_events
 
         st.subheader("Ticker Calendar Results")
-
         data_ticker = st.session_state["ticker_data"]
         if data_ticker:
-            # Prepare events
-            calendar_events_t = []
-            for ev in data_ticker:
-                calendar_events_t.append({
-                    "title": ev["title"],
-                    "start": ev["start"],
-                    "end": ev["end"],
-                    "color": ev["color"]
-                })
-
+            calendar_events_t = [
+                {"title": ev["title"], "start": ev["start"], "end": ev["end"], "color": ev["color"]}
+                for ev in data_ticker
+            ]
             cal_options_ticker = {
                 "initialView": "dayGridMonth",
                 "headerToolbar": {
@@ -320,20 +316,15 @@ def main():
                 },
                 "navLinks": True,
             }
-
             calendar(events=calendar_events_t, options=cal_options_ticker, key="ticker_cal")
-
             st.write("Data Table")
-            df_t = pd.DataFrame(data_ticker)
-            st.dataframe(df_t, use_container_width=True)
+            st.dataframe(pd.DataFrame(data_ticker), use_container_width=True)
         else:
-            #st.write("No data retrieved. Check your options and press the button.")
             st.write(" ")
 
 if __name__ == "__main__":
     main()
-    
-    
+
 hide_streamlit_style = """
 <style>
 #MainMenu {visibility: hidden;}