Task 1: Multi-Route Flask Microservice API

Create a script named flask_api_task.py inside your lesson_57 folder:

• Instantiate a Flask app and register three routes:
  • GET /api/status → Returns {"status": "RUNNING", "version": "1.0.0"} with status code 200.
  • GET /api/users/ → Returns user JSON dictionary if uid > 0 else 404 error.
  • POST /api/echo → Parses incoming JSON body and echoes it back with status code 201.
• Test all three endpoints using app.test_client() and print status codes and JSON outputs using f-strings.

Task 2: Pattern-Matched Web Route Request Dispatcher

Create a script named flask_dispatcher_task.py:

• Build function route_request_event(method: str, path: str, payload: dict | None = None) -> str.
• Write a match-case dispatcher:
  • case ("GET", "/health", _) → Return "200_HEALTH_OK".
  • case ("POST", "/login", {"user": str(u), "pass": str(p)}) if len(p) >= 8 → Return "200_AUTH_SUCCESS".
  • case ("POST", "/login", _) → Return "400_WEAK_PASSWORD".
  • case _ → Return "404_ROUTE_MISSING".
• Execute test calls across 4 route combinations and print output result strings.

Task 3: Master Review Capstone Project — Production Enterprise Web Service & API Gateway OS (`web_service_os.py`)

Create a script named web_service_os.py inside your lesson_57 folder. This assignment tests and integrates **ALL concepts learned across Lessons 1 through 57**.

Project Architectural Requirements Specification:

1. Flask Web Development Architecture (Lesson 57):
   • Construct a modular Flask application with dynamic URL converters, request JSON parsing (`request.get_json()`), query arguments (`request.args`), and Jinja2 HTML template rendering (`render_template_string`).
   • Verify application routes using Flask's built-in test_client() context manager.
2. RPA & Office Automation Integration (Lesson 56):
   • Generate Excel summary reports via openpyxl and export email payload alerts using email.message.EmailMessage when specific Flask routes are invoked.
3. Web Scraping Integration (Lesson 55):
   • Extract HTML DOM elements using BeautifulSoup4 (`bs4`) to serve populated dashboard views inside Flask routes.
4. HTTP APIs & requests Integration (Lesson 54):
   • Integrate background HTTP external health checks via requests.Session().
5. SQLite Persistence Integration (Lesson 53):
   • Persist Web API request log records into an SQLite database table using parameterized SQL statements and sqlite3.Row.
6. Security, Performance & Memory Hardening (Lesson 52):
   • Use __slots__ across core domain models for memory optimization.
   • Read web secret keys and port configurations from environment variables using os.environ.
7. Packaging & Distribution Integration (Lesson 51):
   • Include a programmatically generated pyproject.toml package specification string and an argparse CLI entry point structure.
8. Clean Code, Documentation & Refactoring (Lesson 50):
   • Apply SOLID principles, DRY, and Google Style Docstrings across all functions and classes.
9. Testing & Quality Assurance (Lessons 47-48):
   • Include unit tests verified via pytest fixtures testing Flask routes.
10. Asyncio & Concurrency Integration (Lessons 45-46):
    • Incorporate thread pool workers or async event loops for background task execution.
11. Temporal & RegEx Text Processing (Lessons 43-44):
    • Parse UTC-aware timestamps using datetime and zoneinfo.ZoneInfo.
    • Pre-compile RegEx patterns with Named Groups for parsing HTTP URI paths.
12. Type Hints, Generics & Static Safety (Lesson 42):
    • Apply explicit modern type annotations (X | Y, list[str], dict[str, Any]) throughout all functions and classes.
13. Metaprogramming, Closures & Decorators (Lessons 40-41):
    • Build function factories and 3-level configurable decorators with @functools.wraps.
14. Iterators & Generators (Lesson 39):
    • Implement generator functions streaming web log cursor rows lazily with $O(1)$ memory.
15. Full OOP Architecture (Lessons 32-38):
    • Define abstract base class BaseWebService(ABC) and concrete Data Classes WebRouteRecord and APIAuditEntry.
    • Build composite manager WebServiceOS composing database persistence drivers and web server context handles.
16. Observability & Fault Tolerance (Lessons 29-31):
    • Set up multi-handler logging to console and web_service.log file.
    • Incorporate developer assertions (assert) verifying route response bounds.
    • Define custom exception hierarchy (WebServiceOSError, RouteNotFoundError).
17. Context Managers & Persistence Layer (Lessons 27-30):
    • Use custom class-based context managers to manage test client handles.
    • Persist JSON payload backups to web_db.json and export CSV reports to route_audit.csv using pathlib.Path.
18. Nested Collections & Comprehensions (Lessons 21-26):
    • Maintain in-memory registry dictionaries mapping IDs to Data Class Instances.
    • Use List and Dictionary Comprehensions to clean and transform records.
19. Advanced Function Parameters & Scope (Lessons 15-17):
    • Structure logic into pure modular functions with type hints, docstrings, early return Guard Clauses, and *args / **kwargs logging.
20. Indefinite & Definite Loops (Lessons 13-14):
    • Run the interactive CLI interface inside a continuous while True menu loop.
    • Iterate through output reports using for loops with enumerate() and .items().
21. Pattern Matching CLI Dispatcher (Lesson 12):
    • Process user CLI command tokens inside a match-case block with web server match guards:
      • case ["TEST", "GET", route_path] → Simulate GET request via Flask test_client.
      • case ["TEST", "POST", route_path, json_str] → Simulate POST request with JSON payload.
      • case ["AUDIT", "ROUTES"] → Route web request tuples using match-case pattern dispatcher.
      • case ["EXPORT", "CSV"] → Export completed route access history to CSV.
      • case ["EXIT" | "QUIT"] → Terminate session safely using a sentinel flag.
      • case _ → Output command error message.
22. Conditionals, Formatting & Foundations (Lessons 1-11):
    • Sanitize all inputs using .strip() and .upper().
    • Format tabular reports using f-strings with field width alignment specifiers (:<15, :>10) and clear visual borders.