TonyDain

Streamlit is a powerful framework for building data-driven web applications in Python, but it lacks built-in support for Model-View-Controller (MVC) architecture. However, you can structure your Streamlit app using an MVC-like pattern to improve maintainability and scalability.

1. Understanding MVC in Streamlit

• Model (M) → Manages data, fetching, processing, and storage.
• View (V) → Handles UI, displays data, and interacts with the user.
• Controller (C) → Manages user input and updates the model/view accordingly.

Since Streamlit is UI-centric, it does not have a strict controller, but we can manage business logic using functions.

2. Folder Structure for MVC in Streamlit

A well-structured Streamlit project might look like this:

streamlit_mvc/
│── app.py               # Main entry point (controller)
│── models/
│   ├── data_loader.py   # Handles data fetching & processing
│   ├── database.py      # Manages database operations
│── views/
│   ├── home.py          # UI for the home page
│   ├── dashboard.py     # UI for the dashboard
│── controllers/
│   ├── app_controller.py # Handles app logic
│── utils/
│   ├── helpers.py       # Utility functions
│── assets/
│   ├── styles.css       # Custom styling (if needed)
│   ├── images/          # Store images
│── requirements.txt     # Dependencies
│── README.md            # Documentation

3. Implementing MVC in Streamlit

1️⃣ Model (Data Handling)

Create a file models/data_loader.py to fetch and process data.

# models/data_loader.py
import pandas as pd

def load_data():
    """Loads sample data for the app."""
    data = {
        'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'Toronto', 'London']
    }
    return pd.DataFrame(data)

2️⃣ View (UI)

Create a file views/home.py for the home page UI.

# views/home.py
import streamlit as st

def home_page():
    st.title("Welcome to the Streamlit MVC App")
    st.write("This is the home page UI.")

Create another file views/dashboard.py for the dashboard UI.

# views/dashboard.py
import streamlit as st

def dashboard_page(data):
    st.title("Dashboard")
    st.write("### User Data")
    st.dataframe(data)

3️⃣ Controller (Application Logic)

Create a file controllers/app_controller.py to control app logic.

# controllers/app_controller.py
from models.data_loader import load_data
from views.home import home_page
from views.dashboard import dashboard_page

def run_app():
    """Controls app navigation and logic."""
    import streamlit as st

    st.sidebar.title("Navigation")
    page = st.sidebar.radio("Go to", ["Home", "Dashboard"])

    if page == "Home":
        home_page()
    elif page == "Dashboard":
        data = load_data()
        dashboard_page(data)

4️⃣ Main Application (app.py)

This is the entry point for running the app.

# app.py
import streamlit as st
from controllers.app_controller import run_app

if __name__ == "__main__":
    run_app()

4. Running the Streamlit App

To start the app, run:

streamlit run app.py

5. Benefits of Using MVC with Streamlit

✅ Separation of concerns → Easier to maintain and scale
✅ Modularity → Allows reusability of components
✅ Improved organization → Code is neatly structured for better readability

Use Case: Handle daily file updates in the backend, perform calculations, and display results in front end

Solution Overview

1. Backend (Model)
   • A script that automatically processes daily files (CSV, Excel, etc.).
   • Store processed results in a database or cache for quick access.
2. Controller
   • Loads and updates data from the backend.
   • Provides functions for performing calculations.
3. Frontend (View)
   • Streamlit app displays processed results.
   • Users can select a date or trigger a manual refresh.

1️⃣ Backend – Handle Daily File Updates

Let’s assume files are stored in a “data/” folder and arrive daily.

File Processing (models/file_processor.py)

import os
import pandas as pd
from datetime import datetime

DATA_FOLDER = "data/"
PROCESSED_FILE = "processed_data.csv"

def get_latest_file():
    """Fetch the latest file from the data folder."""
    files = [f for f in os.listdir(DATA_FOLDER) if f.endswith('.csv')]
    if not files:
        return None
    latest_file = max(files, key=lambda x: os.path.getctime(os.path.join(DATA_FOLDER, x)))
    return os.path.join(DATA_FOLDER, latest_file)

def process_file():
    """Process the latest file and save the result."""
    latest_file = get_latest_file()
    if not latest_file:
        return None
    
    df = pd.read_csv(latest_file)  # Modify for Excel if needed
    
    # Perform calculations (Example: Add a new column)
    df["Processed_Date"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    df["New_Column"] = df["Value"] * 2  # Example calculation

    df.to_csv(PROCESSED_FILE, index=False)
    return df

2️⃣ Controller – Load Data & Handle Processing

Controller Logic (controllers/app_controller.py)

from models.file_processor import process_file
import pandas as pd
import os

PROCESSED_FILE = "processed_data.csv"

def load_data():
    """Load processed data from the backend."""
    if os.path.exists(PROCESSED_FILE):
        return pd.read_csv(PROCESSED_FILE)
    return None

3️⃣ Streamlit App (View)

Frontend UI (app.py)

import streamlit as st
from controllers.app_controller import load_data
from models.file_processor import process_file

st.title("Daily File Processing App")

# Button to manually trigger processing
if st.button("Process Latest File"):
    df = process_file()
    if df is not None:
        st.success("File processed successfully!")
    else:
        st.error("No files found!")

# Display processed data
st.subheader("Processed Data")
data = load_data()
if data is not None:
    st.dataframe(data)
else:
    st.warning("No processed data available.")

4️⃣ Running the App

1. Place your daily CSV files in the “data/” folder.
2. Run the Streamlit app: shCopyEdit

streamlit run app.py

5️⃣ Automating Daily Processing

Instead of manually clicking the button, you can schedule automatic processing.

Option 1: Automate Using a Cron Job (Linux/macOS)

0 0 * * * python /path/to/models/file_processor.py

Option 2: Automate with Windows Task Scheduler

1. Open Task Scheduler → Create Basic Task.
2. Set it to run python file_processor.py daily.

✅ Automatic File Handling → Picks the latest file every day.
✅ Efficient Processing → Only processes new data.
✅ Real-Time UI Updates → Users always see the latest results.