A secure, centralized, highly scalable Python architecture simulating a global exam-hosting data center. This system features unique deterministic AI question selection, Zero-Trust cryptographic authentication handshakes, real-time server-side grading, and an advanced Hybrid Edge-AI Proctoring Simulation with an automatic failure trigger mechanism.

• Equal-Weight Dynamic Randomization: Uses an algorithmic structural blueprint. Every candidate receives entirely different questions, but the topic matrix, global question counts, and point weightages remain identically balanced to ensure absolute fairness.
• Cryptographic Session Handshakes: Implements JSON Web Tokens (JWT) signed with a central enterprise security key (HS256). This mitigates client-side identity hijacking and prevents replay injection attacks.
• Edge-Telemetry Simulation (Camera/Behavioral Tracking): Simulates hybrid-edge browser monitoring agent arrays (tracking window focus shifts, tab switching, and mock camera frame indicators).
• Automated Hard Lockout Failure Trigger: If a candidate triggers more than 3 telemetry warnings, the backend data center instantly revokes their cryptographic authorization token, discards their exam write-access, and logs a comprehensive audit report flagged as FAILED_BY_PROCTOR_INTERVENTION.
• Server-Side Blind Grading: Correct answer arrays reside entirely inside the secure database container. The client browser has no access to the keys; grading metrics are computed blindly on the server to prevent inspector tool tampering.

  [Candidate Browser Session]
              │
              ├── (Simulated Webcam/Tab Telemetry Event) ──> [/api/security-log]
              │                                                    │
              │                                          [Backend Violation Check]
              │                                                    │
              │                                          ├── Count <= 3: Issues Warning Alert
              │                                          └── Count >  3: Triggers HARD_LOCKOUT
              │
              └── (Valid Submission Sequence) ─────────────> [/api/submit-exam]
                                                                   │
                                                         [Server-Side Blind Grading]

Follow these terminal commands sequentially to configure and test this project inside an isolated, native virtual environment on macOS:

# 1. Clone your project repository (Replace with your actual GitHub URL later)
git clone https://github.com
cd secure-exam-datacenter-demo

# 2. Establish isolated macOS Native Python 3 Environment
python3 -m venv venv

# 3. Trigger Environment Activation
source venv/bin/activate

# 4. Install Architecture Dependency Locks
pip install -r requirements.txt

Execute the central server script within your active environment session:

python app.py

Open your browser and navigate to the data center network hub at: http://127.0.0.1:5000

1. Login as STUDENT_A and observe your questions.
2. Click Reset Demo, then login as STUDENT_B.
3. Notice that the questions and multiple-choice layouts have changed completely, but the max_possible_points remains strictly locked at 20.

1. Start an exam session.
2. Simulate a camera or browsing violation by clicking your browser’s URL bar or switching to another window tab, then coming back.
3. The system will throw an alert warning: Violations: 1/3.
4. Repeat this action until you reach the 4th infraction. The central data center will instantly execute a hard lockout, revoke your token, and display the backend forensic HARD_LOCKOUT JSON payload mapping the timestamps of each infraction.

1. Start an exam session.
2. Sit idle for 30 seconds without interacting with the system.
3. The server-side token expiration threshold will trip, force-submitting your partial answers automatically.

1. Physical Compute Layout: Transition the backend to cluster environments powered by enterprise-tier GPUs (e.g., NVIDIA H100 arrays) running local instance orchestrations like Ollama or vLLM.
2. Proctoring Telemetry: Inject automated computer vision tracking scripts (OpenCV face-mesh layers) to monitor continuous student identity and browser focus flags.