iotlabkit 1.0.0__py3-none-any.whl

iotlabkit/registry.py

@@ -0,0 +1,705 @@
+"""Registry of supported IoT practical programs (Programs 5 through 17).
+
+Strictly excludes Programs 1, 2, 3, 4, and 18 as per syllabus specification.
+Provides complete metadata, prerequisites, dependencies, setup instructions,
+and generator linkages for each practical.
+"""
+
+from dataclasses import dataclass, field
+from typing import Callable, Dict, List, Optional, Tuple
+
+SUPPORTED_PROGRAM_IDS = set(range(5, 18))  # 5 through 17 inclusive
+EXCLUDED_PROGRAM_IDS = {1, 2, 3, 4, 18}
+
+
+@dataclass
+class ProgramInfo:
+    """Metadata and operational requirements for a laboratory practical."""
+
+    id: int
+    code: str
+    title: str
+    layer: str
+    description: str
+    objective: str
+    requires_internet: bool
+    requires_credentials: bool
+    requires_broker: bool
+    requires_dataset: bool
+    requires_server: bool
+    dependencies: List[str]
+    source_info: str
+    generated_files: List[str]
+    prerequisites: List[str]
+    setup_steps: List[str]
+    viva_preview: List[Tuple[str, str]]
+
+    def get_generator(self) -> Callable[[str, str], Dict[str, str]]:
+        """Dynamically imports and returns the program's template generator function."""
+        module_name = f"iotlabkit.templates.program_{self.code}"
+        try:
+            import importlib
+            mod = importlib.import_module(module_name)
+            return getattr(mod, "generate")
+        except (ImportError, AttributeError) as err:
+            raise RuntimeError(
+                f"Generator for Program {self.id} ({module_name}) could not be loaded: {err}"
+            )
+
+
+# Complete specifications for Programs 5 through 17
+PROGRAMS: Dict[int, ProgramInfo] = {
+    5: ProgramInfo(
+        id=5,
+        code="05",
+        title="HTTP REST API + Cloud Database + Dashboard",
+        layer="Communication and Application Layer",
+        description=(
+            "Collects real environmental sensor readings (temperature and humidity), "
+            "transmits records via an HTTP REST API server, persists records in a cloud "
+            "database (Supabase PostgreSQL / Firebase), and displays real-time telemetry "
+            "on an interactive web dashboard."
+        ),
+        objective=(
+            "Understand HTTP REST principles (GET/POST/JSON) in IoT pipelines, cloud database "
+            "table design, and live telemetry dashboard visualization."
+        ),
+        requires_internet=True,
+        requires_credentials=True,
+        requires_broker=False,
+        requires_dataset=False,
+        requires_server=True,
+        dependencies=["requests", "python-dotenv", "flask", "streamlit"],
+        source_info="Real hardware DHT sensor or user-supplied real-time temperature/humidity measurements",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "server.py",
+            "client_sender.py",
+            "dashboard.py",
+            "supabase_schema.sql",
+            "firebase_setup.md",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "A free Supabase account (or Firebase project)",
+            "Web browser for dashboard",
+        ],
+        setup_steps=[
+            "Copy `.env.example` to `.env` and fill in Supabase/Firebase credentials.",
+            "Run `python server.py` in Terminal 1 to start the REST API.",
+            "Run `python client_sender.py` in Terminal 2 to stream real sensor readings.",
+            "Run `streamlit run dashboard.py` in Terminal 3 to view live metrics.",
+        ],
+        viva_preview=[
+            ("Why is HTTP REST used in IoT applications?",
+             "HTTP REST provides a universally supported, stateless protocol using standard methods (GET, POST) and JSON payloads, making cloud integration straightforward."),
+            ("What is the difference between Supabase and Firebase for IoT storage?",
+             "Supabase provides an open-source relational PostgreSQL database accessible via PostgREST, whereas Firebase provides a NoSQL document/realtime database (Firestore)."),
+        ],
+    ),
+    6: ProgramInfo(
+        id=6,
+        code="06",
+        title="MQTT + Cloud Database + Dashboard",
+        layer="Communication and Application Layer",
+        description=(
+            "Implements an MQTT subscriber that connects to an external broker, receives "
+            "live sensor telemetry payloads, parses the JSON data, stores records in a "
+            "cloud database (Supabase / Firebase), and renders the history on a dashboard."
+        ),
+        objective=(
+            "Learn publish/subscribe messaging architecture, topic design, QoS levels, and "
+            "decoupled data persistence from MQTT into cloud storage."
+        ),
+        requires_internet=True,
+        requires_credentials=True,
+        requires_broker=True,
+        requires_dataset=False,
+        requires_server=False,
+        dependencies=["paho-mqtt", "requests", "python-dotenv", "streamlit"],
+        source_info="Real sensor readings published to configured MQTT broker topic",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "subscriber.py",
+            "publisher.py",
+            "dashboard.py",
+            "supabase_schema.sql",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "Access to an MQTT broker (e.g. HiveMQ public broker or Mosquitto)",
+            "Supabase or Firebase credentials",
+        ],
+        setup_steps=[
+            "Copy `.env.example` to `.env` and set broker address and cloud DB keys.",
+            "Run `python subscriber.py` to listen for MQTT messages and write to DB.",
+            "Run `python publisher.py` to transmit real sensor readings.",
+            "Run `streamlit run dashboard.py` to inspect stored telemetry.",
+        ],
+        viva_preview=[
+            ("How does MQTT differ from HTTP in IoT communications?",
+             "MQTT uses a lightweight publish/subscribe pattern over persistent TCP connections with minimal packet overhead (2-byte header), whereas HTTP uses request/response with larger headers."),
+            ("What are MQTT QoS levels?",
+             "QoS 0 is 'At most once' (fire and forget), QoS 1 is 'At least once' (acknowledged), and QoS 2 is 'Exactly once' (four-step handshake)."),
+        ],
+    ),
+    7: ProgramInfo(
+        id=7,
+        code="07",
+        title="ThingsBoard + MQTT Telemetry",
+        layer="Communication and Application Layer",
+        description=(
+            "Publishes real-time IoT sensor telemetry (temperature, humidity, status) to "
+            "ThingsBoard IoT Platform using MQTT. Includes a comprehensive visual guide "
+            "for building ThingsBoard widgets, digital gauges, and time-series line charts."
+        ),
+        objective=(
+            "Master industry-standard IoT device management platforms, telemetry attribute "
+            "provisioning, access token authentication, and cloud widget visualization."
+        ),
+        requires_internet=True,
+        requires_credentials=True,
+        requires_broker=True,
+        requires_dataset=False,
+        requires_server=False,
+        dependencies=["paho-mqtt", "python-dotenv"],
+        source_info="Real sensor readings or user measurements sent to ThingsBoard",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "main.py",
+            "thingsboard_dashboard_guide.md",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "Free ThingsBoard Cloud account (thingsboard.cloud) or local ThingsBoard CE",
+            "ThingsBoard Device Access Token",
+        ],
+        setup_steps=[
+            "Create a Device on ThingsBoard and copy the Device Access Token.",
+            "Configure `THINGSBOARD_ACCESS_TOKEN` in `.env`.",
+            "Execute `python main.py` to start publishing live telemetry.",
+            "Follow `thingsboard_dashboard_guide.md` to add widgets to your ThingsBoard dashboard.",
+        ],
+        viva_preview=[
+            ("What is the standard ThingsBoard telemetry MQTT topic?",
+             "`v1/devices/me/telemetry` is used to send timeseries telemetry, while `v1/devices/me/attributes` is used for client-side device attributes."),
+            ("How does ThingsBoard authenticate MQTT devices?",
+             "ThingsBoard authenticates devices primarily using an Access Token passed as the MQTT client username (with an empty password)."),
+        ],
+    ),
+    8: ProgramInfo(
+        id=8,
+        code="08",
+        title="CoAP Client and Server Environmental Monitoring",
+        layer="Communication and Application Layer",
+        description=(
+            "Implements a real RFC 7252 CoAP (Constrained Application Protocol) server over UDP "
+            "exposing environmental sensor endpoints (/temperature, /humidity, /environmental), "
+            "paired with a CoAP client that executes GET requests and renders readings."
+        ),
+        objective=(
+            "Understand UDP-based constrained IoT protocols, CoAP 4-byte header architecture, "
+            "Uri-Path options, Content-Format negotiation, and terminal-separated execution."
+        ),
+        requires_internet=False,
+        requires_credentials=False,
+        requires_broker=False,
+        requires_dataset=False,
+        requires_server=True,
+        dependencies=[],  # Pure Python RFC 7252 implementation with zero mandatory dependencies
+        source_info="Real hardware or user-configured ambient readings exposed via CoAP resources",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "server.py",
+            "client.py",
+            "coap_core.py",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "Two open terminal windows (one for server, one for client)",
+        ],
+        setup_steps=[
+            "Open Terminal 1 and start the CoAP server: `python server.py`.",
+            "Open Terminal 2 and query the server: `python client.py`.",
+            "Optionally request specific resources: `python client.py --resource /temperature`.",
+        ],
+        viva_preview=[
+            ("Why is CoAP designed on top of UDP instead of TCP?",
+             "UDP eliminates connection setup handshakes and header overhead, making it ideal for microcontrollers with strict memory, bandwidth, and battery constraints."),
+            ("What is the standard UDP port for CoAP?",
+             "Port 5683 for unencrypted CoAP, and port 5684 for CoAP over Datagram Transport Layer Security (DTLS/coaps)."),
+        ],
+    ),
+    9: ProgramInfo(
+        id=9,
+        code="09",
+        title="Online and Local MQTT Brokers (HiveMQ & Mosquitto)",
+        layer="Communication and Application Layer",
+        description=(
+            "Provides publisher and subscriber implementations capable of connecting to both "
+            "HiveMQ (online cloud broker) and Eclipse Mosquitto (local self-hosted broker). "
+            "Includes a beginner-friendly comparison of online vs. local broker trade-offs."
+        ),
+        objective=(
+            "Learn broker configuration, network ports (1883/8883), authentication, firewall "
+            "settings, and trade-offs between cloud-hosted and edge-hosted MQTT brokers."
+        ),
+        requires_internet=True,  # For HiveMQ; False if testing purely local Mosquitto
+        requires_credentials=False,
+        requires_broker=True,
+        requires_dataset=False,
+        requires_server=True,
+        dependencies=["paho-mqtt", "python-dotenv"],
+        source_info="Real environmental telemetry published across local and cloud MQTT brokers",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "publisher.py",
+            "subscriber.py",
+            "broker_comparison.md",
+            "mosquitto_setup_guide.md",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "Internet access (for HiveMQ) OR Eclipse Mosquitto installed locally",
+        ],
+        setup_steps=[
+            "Configure `.env` to select either online (HiveMQ) or local (Mosquitto) broker.",
+            "To test local broker, install and launch Mosquitto (`sudo systemctl start mosquitto`).",
+            "Start subscriber in Terminal 1: `python subscriber.py --broker hivemq`.",
+            "Publish messages in Terminal 2: `python publisher.py --broker hivemq`.",
+            "Switch to local broker: `python subscriber.py --broker local`.",
+        ],
+        viva_preview=[
+            ("Compare HiveMQ Online and Local Eclipse Mosquitto.",
+             "HiveMQ Online requires zero installation and enables remote device access over the internet, but depends on internet connectivity. Mosquitto provides ultra-low latency on local LANs and complete data privacy, but requires local installation and port-forwarding for external access."),
+            ("What does the Mosquitto configuration `allow_anonymous true` mean?",
+             "It allows clients to connect without supplying a username and password, commonly used in development and private lab networks."),
+        ],
+    ),
+    10: ProgramInfo(
+        id=10,
+        code="10",
+        title="CoAP Environmental Monitoring (Open-Meteo + DB + Dashboard)",
+        layer="Communication and Application Layer",
+        description=(
+            "Fetches live weather and air-quality telemetry from Open-Meteo official APIs for "
+            "configured coordinates (default: 10.0159, 76.3419), exposes the live data over a "
+            "CoAP server, retrieves it via a CoAP client, stores records in a cloud database "
+            "(Supabase / Firebase), and renders the environmental metrics on a dashboard."
+        ),
+        objective=(
+            "Integrate multi-source live REST APIs, bridge HTTP REST to CoAP, handle network "
+            "timeouts gracefully, and persist multi-variable environmental records to cloud DB."
+        ),
+        requires_internet=True,
+        requires_credentials=True,
+        requires_broker=False,
+        requires_dataset=False,
+        requires_server=True,
+        dependencies=["requests", "python-dotenv", "streamlit"],
+        source_info="Open-Meteo Forecast & Air Quality Live APIs (Lat: 10.0159, Lon: 76.3419)",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "coap_env_server.py",
+            "coap_env_client.py",
+            "dashboard.py",
+            "supabase_schema.sql",
+            "coap_core.py",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "Active internet connection for Open-Meteo APIs",
+            "Supabase or Firebase credentials",
+        ],
+        setup_steps=[
+            "Configure coordinates and cloud database keys in `.env`.",
+            "Run `python coap_env_server.py` in Terminal 1 to fetch live data and start CoAP service.",
+            "Run `python coap_env_client.py` in Terminal 2 to fetch readings via CoAP and write to DB.",
+            "Run `streamlit run dashboard.py` in Terminal 3 to monitor the environmental dashboard.",
+        ],
+        viva_preview=[
+            ("Why is CoAP suitable for environmental monitoring stations?",
+             "Environmental stations frequently operate on solar or battery power with cellular/satellite links. CoAP minimizes transmission energy and packet overhead compared to HTTP."),
+            ("How does the bridge architecture work in this practical?",
+             "The server polls the Open-Meteo REST API, formats the data into compact JSON, serves it over CoAP UDP, and the client receives and persists it into Supabase/Firebase."),
+        ],
+    ),
+    11: ProgramInfo(
+        id=11,
+        code="11",
+        title="ISS Real-Time Location Tracking & Trajectory Analysis",
+        layer="Data Analytics Layer",
+        description=(
+            "Continuously collects real orbital telemetry from the International Space Station "
+            "at 5-second intervals (default: 100 records ≈ 8.3 minutes) using official live APIs "
+            "(Open-Notify with WhereTheISS HTTPS fallback). Computes orbital velocity, distance "
+            "traveled via Haversine formula, generates trajectory plots, and renders an analysis dashboard."
+        ),
+        objective=(
+            "Master real-time polling loops, CSV time-series persistence, geospatial distance "
+            "calculation (Haversine formula), and dynamic orbital trend visualization."
+        ),
+        requires_internet=True,
+        requires_credentials=False,
+        requires_broker=False,
+        requires_dataset=False,
+        requires_server=False,
+        dependencies=["requests", "pandas", "matplotlib", "streamlit"],
+        source_info="Live ISS Orbit APIs: Open-Notify (`api.open-notify.org`) and WhereTheISS (`api.wheretheiss.at`)",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "collector.py",
+            "analyzer.py",
+            "dashboard.py",
+            "data/iss_locations.csv",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "Active internet connection to reach ISS orbital APIs",
+        ],
+        setup_steps=[
+            "Run `python collector.py --count 100 --interval 5` to collect 100 live orbital records.",
+            "Run `python analyzer.py` to calculate orbital metrics and generate trend charts.",
+            "Run `streamlit run dashboard.py` to view the interactive trajectory map and stats.",
+        ],
+        viva_preview=[
+            ("How long does it take to collect 100 records at 5-second intervals?",
+             "100 samples * 5 seconds = 500 seconds, which is approximately 8.33 minutes (~8 minutes 20 seconds)."),
+            ("What is the Haversine formula and why is it used here?",
+             "The Haversine formula calculates the great-circle distance between two points on a sphere given their latitudes and longitudes, accounting for Earth's curvature."),
+        ],
+    ),
+    12: ProgramInfo(
+        id=12,
+        code="12",
+        title="USGS Global Earthquake Statistical & Time-Series Analysis",
+        layer="Data Analytics Layer",
+        description=(
+            "Queries the official USGS Earthquake Hazards API for real seismic events across the "
+            "past seven weeks (dynamically calculated at runtime). Performs statistical analysis "
+            "on magnitude and focal depth, investigates tsunami triggers, generates analytical "
+            "charts, and provides an interactive Streamlit dashboard."
+        ),
+        objective=(
+            "Understand GeoJSON parsing, dynamic runtime date filtering, seismic distribution "
+            "statistics, depth vs. magnitude scatter analysis, and interactive data visualization."
+        ),
+        requires_internet=True,
+        requires_credentials=False,
+        requires_broker=False,
+        requires_dataset=False,
+        requires_server=False,
+        dependencies=["requests", "pandas", "matplotlib", "streamlit"],
+        source_info="USGS Earthquake API (`earthquake.usgs.gov/fdsnws/event/1/query`)",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "fetch_data.py",
+            "analyzer.py",
+            "dashboard.py",
+            "data/earthquakes.csv",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "Active internet connection for USGS API",
+        ],
+        setup_steps=[
+            "Run `python fetch_data.py` to fetch seismic events from the past 7 weeks.",
+            "Run `python analyzer.py` to produce statistical summaries and charts in `output/`.",
+            "Run `streamlit run dashboard.py` to launch the interactive seismic dashboard.",
+        ],
+        viva_preview=[
+            ("Why is the date range calculated dynamically at runtime instead of hardcoded?",
+             "Earthquake activity is continuous; dynamically computing `today - 49 days` ensures the practical always analyzes recent, relevant real-world seismic data rather than expired historical dates."),
+            ("What information does focal depth provide about an earthquake?",
+             "Focal depth (0-70 km shallow, 70-300 km intermediate, >300 km deep) indicates where the rupture occurred; shallow quakes typically cause greater surface destruction."),
+        ],
+    ),
+    13: ProgramInfo(
+        id=13,
+        code="13",
+        title="Kochi Meteorological Weather Trend & Correlation Analysis",
+        layer="Data Analytics Layer",
+        description=(
+            "Extracts real meteorological observations for Kochi (Lat: 9.93, Lon: 76.27) from "
+            "Open-Meteo. Evaluates temperature, relative humidity, and wind speed trends, "
+            "computes Pearson correlation between temperature and humidity, and presents findings "
+            "via plots and a dashboard."
+        ),
+        objective=(
+            "Analyze weather variables, compute statistical dispersions (mean, std, range), "
+            "quantify inverse correlation between temperature and relative humidity, and build dashboards."
+        ),
+        requires_internet=True,
+        requires_credentials=False,
+        requires_broker=False,
+        requires_dataset=False,
+        requires_server=False,
+        dependencies=["requests", "pandas", "matplotlib", "streamlit"],
+        source_info="Open-Meteo Weather API (Kochi coordinates: 9.93°N, 76.27°E)",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "fetch_weather.py",
+            "analyzer.py",
+            "dashboard.py",
+            "data/weather_kochi.csv",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "Active internet connection for Open-Meteo API",
+        ],
+        setup_steps=[
+            "Execute `python fetch_weather.py` to retrieve Kochi meteorological records.",
+            "Execute `python analyzer.py` to compute statistical metrics and trend charts.",
+            "Execute `streamlit run dashboard.py` to launch the meteorological dashboard.",
+        ],
+        viva_preview=[
+            ("What correlation is typically observed between temperature and relative humidity?",
+             "An inverse (negative) correlation is standard; as temperature rises during daytime, the saturation vapor pressure of air increases, reducing relative humidity if absolute moisture is constant."),
+            ("Why is Open-Meteo API popular for IoT and educational projects?",
+             "It provides high-precision global meteorological forecasts and historical reanalysis without requiring API keys, rate-limiting hurdles, or credit card registration."),
+        ],
+    ),
+    14: ProgramInfo(
+        id=14,
+        code="14",
+        title="Kochi Hourly Air Quality & Health Index Analysis",
+        layer="Data Analytics Layer",
+        description=(
+            "Retrieves authentic hourly air-quality measurements for Kochi from Open-Meteo "
+            "Air Quality API (PM10, PM2.5, US AQI). Performs time-series and statistical analysis, "
+            "distinguishes between raw API observations, missing values, and derived statistics, "
+            "and visualizes trends."
+        ),
+        objective=(
+            "Learn particulate matter dynamics ($\text{PM}_{2.5}$ vs. $\text{PM}_{10}$), US AQI health "
+            "hazard categorization, diurnal air quality peaks, and time-series plotting."
+        ),
+        requires_internet=True,
+        requires_credentials=False,
+        requires_broker=False,
+        requires_dataset=False,
+        requires_server=False,
+        dependencies=["requests", "pandas", "matplotlib", "streamlit"],
+        source_info="Open-Meteo Air Quality API (Lat: 9.93, Lon: 76.27)",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "fetch_air_quality.py",
+            "analyzer.py",
+            "dashboard.py",
+            "data/air_quality_kochi.csv",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "Active internet connection for Open-Meteo Air Quality API",
+        ],
+        setup_steps=[
+            "Run `python fetch_air_quality.py` to fetch hourly PM10, PM2.5, and US AQI data.",
+            "Run `python analyzer.py` to compute dispersion metrics and generate plots.",
+            "Run `streamlit run dashboard.py` to inspect hourly trends and health categories.",
+        ],
+        viva_preview=[
+            ("What is the aerodynamic difference between PM2.5 and PM10?",
+             r"PM10 refers to inhalable particles $\le 10\,\mu\text{m}$ (dust, pollen), while PM2.5 refers to fine inhalable particles $\le 2.5\,\mu\text{m}$ (combustion smoke) that can penetrate deep into alveoli and bloodstream."),
+            ("How are missing observations handled in air quality time series?",
+             "They must be clearly distinguished from zero readings (zero is a measurement, NaN is absence of data) and handled via forward filling, linear interpolation, or exclusion during mean computation."),
+        ],
+    ),
+    15: ProgramInfo(
+        id=15,
+        code="15",
+        title="Decision Tree Office Room Occupancy Classification",
+        layer="Machine Learning Layer",
+        description=(
+            "Loads the authentic UCI Occupancy Detection dataset (CC BY 4.0). Analyzes environmental "
+            "features (Temperature, Humidity, Light, CO2, HumidityRatio), trains a Decision Tree "
+            "classifier to predict room occupancy (0 or 1), evaluates with accuracy, classification report, "
+            "and confusion matrix, saves model with joblib, and provides real-time single-sample inference."
+        ),
+        objective=(
+            "Master Decision Tree classification, feature-target separation, Gini impurity / entropy "
+            "splitting criteria, confusion matrix interpretation, and model persistence."
+        ),
+        requires_internet=False,  # Bundled / downloaded official dataset
+        requires_credentials=False,
+        requires_broker=False,
+        requires_dataset=True,
+        requires_server=False,
+        dependencies=["pandas", "scikit-learn", "matplotlib", "joblib", "streamlit"],
+        source_info="UCI Machine Learning Repository Dataset #357 (Occupancy Detection, CC BY 4.0)",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "train.py",
+            "predict.py",
+            "dashboard.py",
+            "data/datatraining.txt",
+            "data/download_dataset.py",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "Scikit-learn, Pandas, Matplotlib installed",
+        ],
+        setup_steps=[
+            "Verify official dataset is present in `data/datatraining.txt` (or run `python data/download_dataset.py`).",
+            "Run `python train.py` to train the Decision Tree, evaluate metrics, and save `model/occupancy_tree.joblib`.",
+            "Run `python predict.py --temp 23.2 --humidity 27.2 --light 426 --co2 721` to classify a new reading.",
+            "Run `streamlit run dashboard.py` to test the model interactively.",
+        ],
+        viva_preview=[
+            ("Which feature is typically the strongest predictor of office room occupancy?",
+             "Light (Lux) is usually the most informative immediate feature because office lights are turned on when occupied, followed closely by CO2 levels rising from human respiration."),
+            ("What is the advantage of Decision Trees for IoT edge deployment?",
+             "Trained Decision Trees consist of simple if-else comparison thresholds, making them computationally lightweight and capable of running on low-power microcontrollers without float-heavy operations."),
+        ],
+    ),
+    16: ProgramInfo(
+        id=16,
+        code="16",
+        title="Linear Regression Ambient Temperature Prediction",
+        layer="Machine Learning Layer",
+        description=(
+            "Utilizes the genuine UCI Beijing Air Quality dataset (UCI ID 501 / PRSA, CC BY 4.0). "
+            "Inspects actual columns, explains feature availability (PM2.5, DEWP, PRES, wind speed), "
+            "handles missing values, trains a Linear Regression model to predict temperature, evaluates "
+            "with MAE, MSE, RMSE, and R², saves model with joblib, and supports new reading predictions."
+        ),
+        objective=(
+            "Perform rigorous column inspection on real datasets, handle missing observations, "
+            "train multivariable linear regression, evaluate regression loss metrics, and explain coefficients."
+        ),
+        requires_internet=False,  # Bundled / downloaded official dataset
+        requires_credentials=False,
+        requires_broker=False,
+        requires_dataset=True,
+        requires_server=False,
+        dependencies=["pandas", "scikit-learn", "matplotlib", "joblib"],
+        source_info="UCI Machine Learning Repository Dataset #501 (Beijing Multi-Site / PM2.5, CC BY 4.0)",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "train.py",
+            "predict.py",
+            "column_inspection.py",
+            "data/beijing_sample.csv",
+            "data/download_dataset.py",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "Scikit-learn, Pandas, Matplotlib installed",
+        ],
+        setup_steps=[
+            "Run `python column_inspection.py` to inspect actual dataset columns and confirm verified features.",
+            "Run `python train.py` to train Linear Regression, print MAE/MSE/RMSE/R², and save model.",
+            "Run `python predict.py --dewp 12.0 --pres 1012.0 --pm25 35.0 --wind 2.5` to predict temperature.",
+        ],
+        viva_preview=[
+            ("Why did we check columns in the Beijing dataset before training?",
+             "In the original UCI 501 Beijing PM2.5 dataset, PM10 is absent (it features pm2.5, DEWP, TEMP, PRES, Iws). Inspecting columns prevents runtime crashes and ensures feature transparency."),
+            ("What does an R² score of 0.85 indicate in regression?",
+             "It means 85% of the variance in the target variable (temperature) is explained by the input features in the linear model."),
+        ],
+    ),
+    17: ProgramInfo(
+        id=17,
+        code="17",
+        title="Random Forest Multi-Class Air Quality Classification",
+        layer="Machine Learning Layer",
+        description=(
+            "Applies the genuine Kaggle 'Air Quality Data in India' dataset (`city_day.csv`, CC0). "
+            "Extracts pollutant features (PM2.5, PM10, NO2, CO, SO2, O3), classifies into CPCB standard "
+            "AQI buckets (Good, Satisfactory, Moderate, Poor, Very Poor, Severe), trains a Random Forest "
+            "classifier, computes feature importances, evaluates with confusion matrix, and enables inference."
+        ),
+        objective=(
+            "Understand ensemble learning with Random Forests, multi-class imbalance handling, "
+            "authoritative CPCB AQI threshold mapping, Gini-based feature ranking, and model export."
+        ),
+        requires_internet=False,  # Bundled / downloaded official dataset
+        requires_credentials=False,
+        requires_broker=False,
+        requires_dataset=True,
+        requires_server=False,
+        dependencies=["pandas", "scikit-learn", "matplotlib", "joblib", "streamlit"],
+        source_info="Kaggle Indian Air Quality Dataset (Rohan Rao, CC0 Public Domain, `city_day.csv`)",
+        generated_files=[
+            "README.md",
+            "requirements.txt",
+            ".env.example",
+            ".gitignore",
+            "train.py",
+            "predict.py",
+            "dashboard.py",
+            "data/city_day_sample.csv",
+            "data/download_dataset.py",
+        ],
+        prerequisites=[
+            "Python 3.9+",
+            "Scikit-learn, Pandas, Matplotlib installed",
+        ],
+        setup_steps=[
+            "Verify `data/city_day_sample.csv` or run `python data/download_dataset.py` to download full dataset.",
+            "Run `python train.py` to train Random Forest, view feature importances, and save model.",
+            "Run `python predict.py --pm25 85 --pm10 140 --no2 32 --co 1.2 --so2 15 --o3 45` to classify air quality.",
+            "Run `streamlit run dashboard.py` to launch the interactive air quality predictor.",
+        ],
+        viva_preview=[
+            ("Why is Random Forest less prone to overfitting than a single Decision Tree?",
+             "Random Forest builds multiple decision trees on random bootstrap subsets of data and random subsets of features (bagging), averaging predictions to reduce variance."),
+            ("What are the official CPCB Indian AQI category ranges?",
+             "Good: 0-50, Satisfactory: 51-100, Moderate: 101-200, Poor: 201-300, Very Poor: 301-400, Severe: 401-500."),
+        ],
+    ),
+}
+
+
+def get_program(program_id: int) -> ProgramInfo:
+    """Retrieves program info by integer ID, strictly enforcing valid range (5-17)."""
+    if program_id in EXCLUDED_PROGRAM_IDS:
+        raise ValueError(
+            f"Program {program_id} is explicitly excluded from the syllabus scope. "
+            f"Only Programs 5 through 17 are supported."
+        )
+    if program_id not in SUPPORTED_PROGRAM_IDS:
+        raise ValueError(
+            f"Invalid Program ID {program_id}. Supported programs are 5 through 17."
+        )
+    return PROGRAMS[program_id]
+
+
+def list_programs() -> List[ProgramInfo]:
+    """Returns a sorted list of all supported programs."""
+    return [PROGRAMS[pid] for pid in sorted(PROGRAMS.keys())]