Streamlit for Data Apps: Build Interactive Dashboards in Pure Python

import streamlit as st
import datetime

# This line runs EVERY time the user does anything in the app.
# Watch the timestamp change every time you interact with a widget.
st.write(f"Script last ran at: {datetime.datetime.now().strftime('%H:%M:%S')}")

st.title("Understanding Streamlit's Re-Run Model")

# When the user moves this slider, the ENTIRE script above AND below re-executes.
temperature_celsius = st.slider(
    label="Set temperature (°C)",
    min_value=-20,
    max_value=50,
    value=22  # This is the default value on first load
)

# By the time we reach this line, temperature_celsius already holds
# whatever value the user selected — no callbacks needed.
temperature_fahrenheit = (temperature_celsius * 9 / 5) + 32

st.metric(
    label="Temperature in Fahrenheit",
    value=f"{temperature_fahrenheit:.1f} °F",
    delta=f"{temperature_celsius} °C input"  # delta shows a small indicator arrow
)

# Conditional rendering is just plain Python — no special syntax.
if temperature_celsius > 35:
    st.warning("🌡️ That's dangerously hot! Stay hydrated.")
elif temperature_celsius < 0:
    st.info("❄️ Below freezing — roads may be icy.")
else:
    st.success("✅ Comfortable temperature range.")

import streamlit as st
import pandas as pd
import numpy as np
import time

# ── CACHING DATA ─────────────────────────────────────────────────────────────
# The @st.cache_data decorator means this function only runs ONCE per unique
# combination of arguments. After that, Streamlit returns the cached DataFrame.
# Remove this decorator and watch the app slow down on every widget interaction.
@st.cache_data
def load_sales_data(num_records: int) -> pd.DataFrame:
    """Simulate loading sales data from a slow data source."""
    time.sleep(2)  # Pretend this is a slow database query
    rng = np.random.default_rng(seed=42)  # Fixed seed for reproducibility
    return pd.DataFrame({
        "month": pd.date_range(start="2023-01-01", periods=num_records, freq="ME"),
        "revenue": rng.integers(50_000, 200_000, size=num_records),
        "units_sold": rng.integers(100, 1000, size=num_records),
        "region": rng.choice(["North", "South", "East", "West"], size=num_records)
    })

# ── CACHING RESOURCES ─────────────────────────────────────────────────────────
# Use cache_resource for objects that are expensive to create and shouldn't
# be duplicated — like an ML model or a database connection pool.
@st.cache_resource
def load_forecasting_model():
    """Load a pretrained model — only happens once, shared across all users."""
    time.sleep(3)  # Simulate loading a large model file
    st.toast("Model loaded into memory!", icon="🤖")
    # In a real app, this would be: return joblib.load("model.pkl")
    return {"model_name": "LinearForecaster_v2", "accuracy": 0.94}

# ── SESSION STATE ─────────────────────────────────────────────────────────────
# Initialize session state keys safely — only set them if they don't exist yet.
# Doing `st.session_state.click_count = 0` every run would reset the counter!
if "analysis_count" not in st.session_state:
    st.session_state.analysis_count = 0

if "selected_regions" not in st.session_state:
    st.session_state.selected_regions = ["North", "South"]

# ── APP LAYOUT ────────────────────────────────────────────────────────────────
st.title("Sales Dashboard — Caching & State Demo")

num_months = st.slider("How many months of data?", min_value=6, max_value=36, value=12)

# This call benefits from caching — change the slider and only new values
# trigger a fresh load; previously seen values are instant.
with st.spinner("Loading sales data..."):
    sales_df = load_sales_data(num_records=num_months)

# Multi-select widget whose default value is stored in session_state
region_filter = st.multiselect(
    "Filter by region:",
    options=["North", "South", "East", "West"],
    default=st.session_state.selected_regions
)
# Persist the user's selection across re-runs
st.session_state.selected_regions = region_filter

# Filter and display the data
filtered_df = sales_df[sales_df["region"].isin(region_filter)] if region_filter else sales_df

col_left, col_right = st.columns(2)
with col_left:
    st.metric("Total Revenue", f"${filtered_df['revenue'].sum():,.0f}")
with col_right:
    st.metric("Total Units Sold", f"{filtered_df['units_sold'].sum():,}")

st.line_chart(filtered_df.set_index("month")["revenue"], use_container_width=True)

# Track how many times the user has run an analysis in this session
if st.button("Run Forecast"):
    st.session_state.analysis_count += 1
    model = load_forecasting_model()  # Cached — instant after first load
    st.success(f"Forecast complete using {model['model_name']} (accuracy: {model['accuracy']:.0%})")

st.caption(f"You've run {st.session_state.analysis_count} analysis/analyses this session.")

import streamlit as st
import pandas as pd
import numpy as np

# ── PAGE CONFIG — must be the very first Streamlit call in your script ─────────
st.set_page_config(
    page_title="Sales Intelligence Hub",
    page_icon="📊",
    layout="wide",          # 'wide' uses the full browser width
    initial_sidebar_state="expanded"
)

# ── GENERATE SAMPLE DATASET ───────────────────────────────────────────────────
@st.cache_data
def generate_product_sales() -> pd.DataFrame:
    rng = np.random.default_rng(seed=7)
    products = ["Laptop Pro", "Wireless Mouse", "USB-C Hub", "Mechanical Keyboard", "Webcam HD"]
    records = []
    for month_offset in range(12):
        month = pd.Timestamp("2024-01-01") + pd.DateOffset(months=month_offset)
        for product in products:
            records.append({
                "month": month,
                "product": product,
                "units_sold": int(rng.integers(20, 300)),
                "unit_price": float(rng.uniform(15.0, 1200.0)),
                "return_rate": float(rng.uniform(0.01, 0.15))
            })
    df = pd.DataFrame(records)
    df["revenue"] = df["units_sold"] * df["unit_price"]
    return df

product_df = generate_product_sales()

# ── SIDEBAR — acts as a global filter panel ───────────────────────────────────
with st.sidebar:
    st.header("🔧 Filters")
    st.markdown("---")

    # Date range filter
    all_months = sorted(product_df["month"].unique())
    date_range = st.select_slider(
        "Select month range:",
        options=[m.strftime("%b %Y") for m in all_months],
        value=(all_months[0].strftime("%b %Y"), all_months[-1].strftime("%b %Y"))
    )

    selected_products = st.multiselect(
        "Products to include:",
        options=product_df["product"].unique().tolist(),
        default=product_df["product"].unique().tolist()
    )

    st.markdown("---")
    st.caption("Dashboard v1.0 — Sales Intelligence Hub")

# ── APPLY FILTERS ─────────────────────────────────────────────────────────────
start_label, end_label = date_range
start_month = pd.Timestamp(start_label)
end_month = pd.Timestamp(end_label)

filtered_df = product_df[
    (product_df["month"] >= start_month) &
    (product_df["month"] <= end_month) &
    (product_df["product"].isin(selected_products))
].copy()

# ── PAGE TITLE ────────────────────────────────────────────────────────────────
st.title("📊 Sales Intelligence Hub")
st.markdown(f"Showing data from **{start_label}** to **{end_label}** for **{len(selected_products)}** product(s).")

# ── KPI ROW — three equal-width columns ──────────────────────────────────────
kpi1, kpi2, kpi3 = st.columns(3)
with kpi1:
    total_revenue = filtered_df["revenue"].sum()
    st.metric("Total Revenue", f"${total_revenue:,.0f}",
              delta=f"+{total_revenue * 0.08:,.0f} vs last period")
with kpi2:
    total_units = filtered_df["units_sold"].sum()
    st.metric("Units Sold", f"{total_units:,}", delta="+12% MoM")
with kpi3:
    avg_return = filtered_df["return_rate"].mean()
    st.metric("Avg Return Rate", f"{avg_return:.1%}", delta="-0.3%", delta_color="inverse")

st.markdown("---")

# ── TABBED CONTENT ────────────────────────────────────────────────────────────
tab_overview, tab_by_product, tab_raw = st.tabs(["📈 Revenue Trend", "🏷️ By Product", "🗂️ Raw Data"])

with tab_overview:
    monthly_revenue = (
        filtered_df.groupby("month")["revenue"]
        .sum()
        .reset_index()
        .set_index("month")
    )
    st.line_chart(monthly_revenue, use_container_width=True)

with tab_by_product:
    # Side-by-side charts using columns
    chart_col, table_col = st.columns([3, 2])

    product_summary = (
        filtered_df.groupby("product")
        .agg(total_revenue=("revenue", "sum"), total_units=("units_sold", "sum"))
        .sort_values("total_revenue", ascending=False)
    )

    with chart_col:
        st.bar_chart(product_summary["total_revenue"], use_container_width=True)
    with table_col:
        st.dataframe(
            product_summary.style.format("{:,.0f}"),
            use_container_width=True
        )

    # Expander for advanced analytics — keeps the UI clean
    with st.expander("📐 Advanced: Return Rate Analysis"):
        return_df = (
            filtered_df.groupby("product")["return_rate"]
            .mean()
            .reset_index()
            .rename(columns={"return_rate": "avg_return_rate"})
        )
        st.dataframe(return_df.style.format({"avg_return_rate": "{:.1%}"}), use_container_width=True)
        st.caption("Products with return rates above 10% may need quality review.")

with tab_raw:
    # A form prevents re-runs on every keystroke in the search box
    with st.form("data_filter_form"):
        search_term = st.text_input("Search product name:", placeholder="e.g. Laptop")
        min_revenue = st.number_input("Minimum revenue per row ($):", min_value=0, value=0, step=500)
        submitted = st.form_submit_button("Apply Filter")  # Only triggers re-run when clicked

    display_df = filtered_df.copy()
    if submitted:
        if search_term:
            display_df = display_df[display_df["product"].str.contains(search_term, case=False)]
        display_df = display_df[display_df["revenue"] >= min_revenue]

    st.dataframe(
        display_df[["month", "product", "units_sold", "unit_price", "revenue", "return_rate"]]
        .sort_values("month")
        .style.format({
            "unit_price": "${:.2f}",
            "revenue": "${:,.0f}",
            "return_rate": "{:.1%}"
        }),
        use_container_width=True
    )
    st.caption(f"Showing {len(display_df):,} of {len(filtered_df):,} records.")

# ── FILE STRUCTURE FOR DEPLOYMENT ─────────────────────────────────────────────
# your-app/
# ├── app.py                    ← main Streamlit script
# ├── requirements.txt          ← pinned dependencies
# ├── .gitignore                ← must include .streamlit/secrets.toml!
# └── .streamlit/
#     ├── secrets.toml          ← LOCAL ONLY — never commit this
#     └── config.toml           ← safe to commit — UI theme settings

# ── .streamlit/secrets.toml (LOCAL DEVELOPMENT ONLY) ─────────────────────────
# [database]
# host = "prod-db.company.com"
# username = "readonly_user"
# password = "super_secret_password_123"
#
# [api]
# openai_key = "sk-..."

# ── .streamlit/config.toml (SAFE TO COMMIT) ───────────────────────────────────
# [theme]
# primaryColor = "#FF6B6B"
# backgroundColor = "#FFFFFF"
# secondaryBackgroundColor = "#F0F2F6"
# textColor = "#262730"
# font = "sans serif"
#
# [server]
# maxUploadSize = 50  # MB — increase for large file uploads

# ── requirements.txt (PIN YOUR VERSIONS!) ────────────────────────────────────
# streamlit==1.35.0
# pandas==2.2.2
# numpy==1.26.4
# plotly==5.22.0
# scikit-learn==1.5.0

# ── APP CODE — using secrets safely ──────────────────────────────────────────
import streamlit as st
import pandas as pd

st.set_page_config(page_title="Secrets Demo", page_icon="🔐")
st.title("🔐 Connecting Securely to External Services")

# st.secrets works identically in local dev (reads from secrets.toml)
# and in Streamlit Cloud (reads from the dashboard's secrets manager).
# Your code NEVER changes between environments — only the secrets storage does.
def get_database_connection_string() -> str:
    """Build connection string from secrets — never from hardcoded values."""
    try:
        db_host = st.secrets["database"]["host"]
        db_user = st.secrets["database"]["username"]
        db_pass = st.secrets["database"]["password"]
        # In a real app: return sqlalchemy.create_engine(f"postgresql://{db_user}:{db_pass}@{db_host}/sales")
        return f"postgresql://{db_user}:***@{db_host}/sales"  # Never log real passwords!
    except KeyError as missing_key:
        st.error(f"Missing secret: {missing_key}. Check your secrets.toml or Cloud dashboard.")
        st.stop()  # Halt execution cleanly — don't let the app run in a broken state

# Show connection status without exposing credentials
connection_string = get_database_connection_string()
st.success(f"✅ Database configured: `{connection_string}`")

# ── FILE UPLOADER — common in deployed data apps ──────────────────────────────
st.markdown("---")
st.subheader("Upload Your Own Data")

uploaded_csv = st.file_uploader(
    label="Upload a CSV file to analyze",
    type=["csv"],                          # Restrict to CSV only
    help="Max file size is 50MB. Ensure the first row contains column headers."
)

if uploaded_csv is not None:
    # st.file_uploader returns a BytesIO-like object — pandas reads it directly
    user_data = pd.read_csv(uploaded_csv)
    st.success(f"Loaded {len(user_data):,} rows and {len(user_data.columns)} columns.")
    st.dataframe(user_data.head(10), use_container_width=True)  # Preview only — never show all rows blindly

    # Download button — let users export processed results
    processed_csv = user_data.describe().to_csv().encode("utf-8")
    st.download_button(
        label="📥 Download Summary Statistics",
        data=processed_csv,
        file_name="summary_statistics.csv",
        mime="text/csv"
    )
else:
    st.info("👆 Upload a CSV file to get started.")

# ── DOCKERFILE (as a comment — for containerized deployment) ──────────────────
# FROM python:3.11-slim
# WORKDIR /app
# COPY requirements.txt .
# RUN pip install --no-cache-dir -r requirements.txt
# COPY . .
# EXPOSE 8080
# HEALTHCHECK CMD curl --fail http://localhost:8080/_stcore/health || exit 1
# ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8080", "--server.address=0.0.0.0"]