How dhivkrish7/fe-gpa-dashboard works
What this project is (based on the provided repo)
From the file tree, this is almost certainly a single-file Python application:
• app.py — the entire application entrypoint (likely a small web/dashboard app).
• requirements.txt — runtime dependencies (this will reveal whether it’s Flask/Dash/Streamlit/FastAPI, etc.).
• README.md — only a name (fe-gpa-dashboard), no architecture notes.
Key implication for diagramming
• a monolithic “single process” app
• minimal internal layering unless app.py implements it
So the first step to “best and most accurate” is: derive the architecture from the imports and runtime entrypoint.
Framework and runtime model
Open requirements.txt and app.py and classify the app:
Common patterns you might see:
• Streamlit
• requirements.txt includes streamlit
• app.py uses import streamlit as st
• Runs as: streamlit run app.py
• Architecture: Streamlit server ↔ browser; Python script reruns on interaction
• Plotly Dash
• dash, plotly
• from dash import Dash, html, dcc
• Runs a Flask server under the hood
• Architecture: browser ↔ Dash/Flask backend; callbacks for interactivity
• Flask
• flask + from flask import Flask
• Routes like @app.route(...)
• Architecture: browser ↔ Flask app; optional DB/external APIs
• FastAPI
• fastapi, uvicorn
• from fastapi import FastAPI
• Architecture: browser/client ↔ FastAPI; maybe JSON API consumed by a UI elsewhere (but no frontend folder exists)
Data sources and external dependencies
In app.py, look for:
• file reads: open(...), pandas.read_csv(...), reading Excel, etc.
• database drivers: sqlalchemy, psycopg2, sqlite3, etc.
• external HTTP calls: requests.get/post, httpx, Google Sheets API, etc.
• auth: OAuth libs, SSO, etc.
Major modules inside app.py
• UI/layout layer (page layout, components)
• business logic (GPA calculation, rules)
• data access layer (load/transform data)
• integrations (external API calls)
Your goal (per your instruction) is to separate into as many components as possible without inventing things that aren’t there.
User interaction loop
• Browser sends request / triggers callback
• App executes Python code (route handler / callback / Streamlit rerun)
• App returns HTML/JS payload or UI update
Dependency direction
• UI depends on computation/data
• computation depends on raw/clean data
• data layer depends on external stores/services
Architectural patterns likely in this repo (and how to represent them)
Because there’s no multi-module layout, the repo is likely:
• Monolithic single-process application
• Possibly MVC-ish (routes/controllers + data + rendering) but in one file
• Or reactive callback model (Streamlit/Dash)
This by:
• One main “App Process” container
• Multiple internal logical components inside it (even if physically co-located)
Python Dashboard App (app.py)
• UI Layer
• Interaction Handlers (routes/callbacks)
• GPA Calculation / Business Rules
• Data Loading + Transform
Data Source
• (placeholder: “CSV/DB/External API — confirm in app.py”)
• User → Browser
• Browser ⇄ Dashboard App (HTTP)
• Dashboard App → Data Source (SQL/FS/HTTPS)
Then replace placeholders with exact technologies once confirmed.
app.py — where does data come from (files/DB/API)? are there authentication/roles?
3) How is it run in practice (local only? gunicorn? streamlit run?) — may be implied by code comments