Refactor: Modularize data source and add chart page

- Extracts data handling into .
- Renames to .
- Adds a new candlestick chart page at .
- Updates dependencies and configurations.

.gitignore

@@ -1,2 +1,4 @@
 .env
 *.parquet
+*.sqlite
+*__pycache__

Dockerfile

@@ -26,4 +26,4 @@ EXPOSE 8501
 
 HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health || exit 1
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+ENTRYPOINT ["streamlit", "run", "src/main.py", "--server.port=8501", "--server.address=0.0.0.0"]

Makefile

@@ -11,7 +11,7 @@ fmt:
 	.venv/bin/isort .
 
 run:
-	APP_ENV=development .venv/bin/streamlit run src/streamlit_app.py
+	APP_ENV=development .venv/bin/streamlit run src/main.py
 
 deploy:
 	@if ! git remote | grep -q '^hf$$'; then git remote add hf git@hf.co:spaces/Arrechenash/dashboard; fi

README.md

@@ -5,7 +5,7 @@ colorFrom: blue
 colorTo: green
 sdk: streamlit
 sdk_version: "1.28.0"
-app_file: src/streamlit_app.py
+app_file: src/main.py
 ---
 
 # dashboard
@@ -16,7 +16,7 @@ pip install -r requirements.txt
 
 ## Run dashboard
 
-streamlit run src/streamlit_app.py
+streamlit run src/main.py
 
 ## Knowledge
 

requirements.txt

@@ -1,3 +1,8 @@
 pandas
+pyarrow
 duckdb
-streamlit
+streamlit
+plotly
+python-dotenv
+alpaca-py
+requests-cache

src/datasource.py

@@ -0,0 +1,67 @@
+import os
+from datetime import datetime, timedelta
+
+import duckdb
+import requests_cache
+import streamlit as st
+from alpaca.data.historical import StockHistoricalDataClient
+from alpaca.data.requests import StockBarsRequest
+from alpaca.data.timeframe import TimeFrame, TimeFrameUnit
+from dotenv import load_dotenv
+
+import datasource
+
+load_dotenv()
+
+ALPACA_API_KEY = os.getenv("ALPACA_API_KEY")
+ALPACA_SECRET_KEY = os.getenv("ALPACA_SECRET_KEY")
+
+if not ALPACA_API_KEY or not ALPACA_SECRET_KEY:
+    st.error(
+        "API keys missing. Set ALPACA_API_KEY and ALPACA_SECRET_KEY in your .env or as secrets/environment variables."
+    )
+    st.stop()
+
+requests_cache.install_cache("alpaca_api_cache", expire_after=120)
+
+
+# Data source
+url = (
+    "stocks.parquet"
+    if os.getenv("APP_ENV") == "development"
+    else "hf://datasets/Arrechenash/stocks/stocks.parquet"
+)
+
+
+@st.cache_data
+def load_symbols():
+    return (
+        duckdb.query(
+            f"SELECT DISTINCT symbol FROM read_parquet('{url}') ORDER BY symbol"
+        )
+        .to_df()["symbol"]
+        .tolist()
+    )
+
+
+@st.cache_data
+def get_data(filters=None):
+    query = f"SELECT * FROM read_parquet('{url}')"
+    if filters:
+        query += " WHERE " + " AND ".join(filters)
+    return duckdb.query(query + " ORDER BY date DESC").to_df()
+
+
+@st.cache_resource
+def get_client():
+    return StockHistoricalDataClient(ALPACA_API_KEY, ALPACA_SECRET_KEY)
+
+
+def get_stock_bars(symbol_or_symbols, date_start, date_end):
+    req = StockBarsRequest(
+        symbol_or_symbols=symbol_or_symbols,
+        timeframe=TimeFrame(amount=5, unit=TimeFrameUnit.Minute),
+        start=str(date_start),
+        end=str(date_end),
+    )
+    return get_client().get_stock_bars(req).df

src/{streamlit_app.py → main.py}

@@ -1,39 +1,10 @@
-import os
-
 import duckdb
 import streamlit as st
 
-# Page configuration
-st.set_page_config(layout="wide")
-
-# Data source
-url = (
-    "stocks.parquet"
-    if os.getenv("APP_ENV") == "development"
-    else "hf://datasets/Arrechenash/stocks/stocks.parquet"
-)
-
-
-@st.cache_data
-def get_data(filters=None):
-    query = f"SELECT * FROM read_parquet('{url}')"
-    if filters:
-        query += " WHERE " + " AND ".join(filters)
-    return duckdb.query(query + " ORDER BY date DESC").to_df()
-
-
-@st.cache_data
-def load_symbols():
-    return (
-        duckdb.query(
-            f"SELECT DISTINCT symbol FROM read_parquet('{url}') ORDER BY symbol"
-        )
-        .to_df()["symbol"]
-        .tolist()
-    )
+from datasource import get_data, load_symbols
 
+st.set_page_config(layout="wide")
 
-# Initialize session state without forcing values onto widgets
 defaults = {
     "date": None,
     "symbols": [],
@@ -49,7 +20,8 @@ for key, value in defaults.items():
     if key not in st.session_state:
         st.session_state[key] = value
 
-# Sidebar filters
+st.title("Market Overview")
+
 with st.sidebar:
     st.session_state.date = st.date_input("Date", value=None)
     st.session_state.symbols = st.multiselect(
@@ -71,10 +43,8 @@ with st.sidebar:
         "Min rel volume", value=st.session_state.min_relvol
     )
 
-    # Placeholder for results count (updated after df load)
     results_placeholder = st.empty()
 
-# Construct query filters
 f = st.session_state
 filters = []
 if f.date:
@@ -92,15 +62,12 @@ if f.min_gap:
 if f.min_run:
     filters.append(f"run_pct >= {f.min_run}")
 
-# Load data
 df = get_data(filters if filters else None)
 
-# Update the sidebar with results count
 with results_placeholder:
     st.markdown("---")
     st.markdown(f"**Results: {len(df)}**")
 
-# UI rendering
 if df.empty:
     st.info("No data found with current filters")
 else:
@@ -117,7 +84,7 @@ else:
         st.selectbox(
             "Y-axis",
             numeric_cols,
-            key="y_axis",  # ✅ No index or value conflicts
+            key="y_axis",
         )
 
     st.scatter_chart(

src/pages/chart.py

@@ -0,0 +1,132 @@
+import pandas as pd
+import plotly.graph_objs as go
+import streamlit as st
+
+from datasource import get_stock_bars, load_symbols
+
+st.set_page_config(layout="wide")
+st.title("Candlestick Chart")
+st.sidebar.title("Filters")
+
+symbol = st.sidebar.text_input("Ticker symbol", value="HTOO").upper()
+date_start = st.sidebar.date_input("Start date", pd.Timestamp("2025-07-22"))
+date_end = st.sidebar.date_input("End date", pd.Timestamp("2025-07-23"))
+
+try:
+    bars = get_stock_bars(symbol, date_start, date_end)
+    if bars.empty:
+        st.warning("No data. Check symbol and dates.")
+    else:
+        bars = bars.reset_index()
+        bars["timestamp"] = bars["timestamp"].dt.tz_convert("America/New_York")
+        bars = bars.set_index("timestamp")
+
+        bars["volume"] = pd.to_numeric(bars["volume"], errors="coerce").fillna(0)
+        typical_price = (bars["high"] + bars["low"] + bars["close"]) / 3.0
+        bars["vwap"] = (typical_price * bars["volume"]).cumsum() / bars[
+            "volume"
+        ].cumsum()
+
+        premarket_mask = bars.index.time < pd.to_datetime("09:30:00").time()
+        premarket_high = (
+            bars.loc[premarket_mask, "high"].max() if premarket_mask.any() else None
+        )
+
+        timestamps = [ts.strftime("%Y-%m-%d %H:%M:%S") for ts in bars.index]
+        open_vals = bars["open"].tolist()
+        high_vals = bars["high"].tolist()
+        low_vals = bars["low"].tolist()
+        close_vals = bars["close"].tolist()
+        vwap_vals = bars["vwap"].tolist()
+        volume_vals = bars["volume"].tolist()
+
+        fig = go.Figure()
+        fig.add_trace(
+            go.Candlestick(
+                x=timestamps,
+                open=open_vals,
+                high=high_vals,
+                low=low_vals,
+                close=close_vals,
+                name="Candlestick",
+            )
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=timestamps,
+                y=vwap_vals,
+                mode="lines",
+                line=dict(color="yellow", width=1),
+                name="VWAP",
+            )
+        )
+        if premarket_high is not None and pd.notna(premarket_high):
+            fig.add_trace(
+                go.Scatter(
+                    x=[timestamps[0], timestamps[-1]],
+                    y=[premarket_high, premarket_high],
+                    mode="lines",
+                    line=dict(color="red", width=1, dash="dash"),
+                    name="Premarket High",
+                )
+            )
+        fig.add_trace(
+            go.Bar(
+                x=timestamps,
+                y=volume_vals,
+                yaxis="y2",
+                marker=dict(color="rgba(200,200,200,0.5)"),
+                name="Volume",
+                opacity=0.5,
+            )
+        )
+
+        bars_dates = pd.to_datetime(bars.index.date).unique()
+        for day in bars_dates:
+            dm = pd.Timestamp(day).strftime("%Y-%m-%d")
+            fig.add_vrect(
+                x0=f"{dm} 04:00:00",
+                x1=f"{dm} 09:30:00",
+                fillcolor="rgba(0, 200, 255, 0.10)",
+                layer="below",
+                line_width=0,
+                annotation_text="Pre-market",
+                annotation_position="top left",
+            )
+            fig.add_vrect(
+                x0=f"{dm} 16:00:00",
+                x1=f"{dm} 20:00:00",
+                fillcolor="rgba(255, 200, 0, 0.08)",
+                layer="below",
+                line_width=0,
+                annotation_text="After-hours",
+                annotation_position="top left",
+            )
+
+        fig.update_layout(
+            title=f"{symbol} 5-min",
+            xaxis_title="Date/Time",
+            yaxis_title="Price",
+            xaxis_rangeslider_visible=False,
+            yaxis=dict(domain=[0.3, 1]),
+            yaxis2=dict(domain=[0, 0.25], title="Volume"),
+            legend=dict(orientation="h"),
+            margin=dict(t=40, b=20),
+            hovermode="x unified",
+            height=720,
+        )
+
+        st.plotly_chart(fig, use_container_width=True)
+        preview_cols = ["open", "high", "low", "close", "volume", "vwap"]
+        if premarket_high is not None and pd.notna(premarket_high):
+            preview_cols.append("premarket_high")
+            bars["premarket_high"] = premarket_high
+        st.write("Data:")
+        st.table(bars[preview_cols].reset_index().head(20))
+
+except Exception as e:
+    st.error(f"Error fetching or plotting data: {e}")
+    import traceback
+
+    st.write("Full traceback:")
+    st.code(traceback.format_exc())