Automation with Files, Spreadsheets and Email

Task 1: Automated Directory Cleanup and Compression Utility

Create a script named file_cleaner_task.py inside your lesson_56 folder:

• Import shutil and pathlib.Path.
• Define function archive_and_clean_logs(log_dir: Path, target_zip: Path) -> bool.
• Scan log_dir for all .log files, copy them to a temporary backup directory, compress the backup using shutil.make_archive(), and delete the temporary folder.
• Print confirmation logs with f-strings.

Task 2: Pattern-Matched RPA Task Dispatcher

Create a script named rpa_dispatcher_task.py:

• Build function process_rpa_instruction(task_tuple: tuple) -> str parsing automation instructions.
• Write a match-case dispatcher:
  • case ("EXCEL_TOTAL", filepath, col_letter) → Return confirmation string for generating Excel totals.
  • case ("EMAIL_ALERT", recipient, message) → Return confirmation string for sending alert email.
  • case ("CLEAN_TEMP", dir_path) → Return confirmation string for directory purge.
  • case _ → Return error string.
• Test function across 4 sample task tuples and print output strings.

Task 3: Master Review Capstone Project — Production Enterprise Office Automation & RPA OS (`office_automation_os.py`)

Create a script named office_automation_os.py inside your lesson_56 folder. This assignment tests and integrates **ALL concepts learned across Lessons 1 through 56**.

Project Architectural Requirements Specification:

1. Office Automation & RPA Architecture (Lesson 56):
   • Implement directory scanning, categorization, and ZIP archive creation using shutil and pathlib.Path.
   • Generate styled, calculated Excel report workbooks using openpyxl with formulas and custom styles.
   • Construct MIME email objects via email.message.EmailMessage with attachments and simulated SMTP transmission.
2. Web Scraping Integration (Lesson 55):
   • Extract market data text elements from HTML documents using BeautifulSoup4 (`bs4`) to populate Excel report rows.
3. HTTP APIs & requests Integration (Lesson 54):
   • Fetch remote operational parameters via requests.Session() with timeouts and error handling.
4. SQLite Persistence Integration (Lesson 53):
   • Persist operational automation logs into an SQLite database table using parameterized SQL statements and sqlite3.Row.
5. Security, Performance & Memory Hardening (Lesson 52):
   • Use __slots__ across automation data model classes for memory optimization.
   • Read SMTP secrets dynamically from environment variables using os.environ.
6. Packaging & Distribution Integration (Lesson 51):
   • Include a programmatically generated pyproject.toml package specification string and an argparse CLI entry point structure.
7. Clean Code, Documentation & Refactoring (Lesson 50):
   • Apply SOLID principles, DRY, and Google Style Docstrings across all functions and classes.
8. Testing & Quality Assurance (Lessons 47-48):
   • Include unit tests verified via pytest fixtures and unittest.mock.
9. Asyncio & Concurrency Integration (Lessons 45-46):
   • Incorporate thread pool workers or async event loops for parallel multi-attachment email processing.
10. Temporal & RegEx Text Processing (Lessons 43-44):
    • Parse UTC-aware automation timestamps using datetime and zoneinfo.ZoneInfo.
    • Pre-compile RegEx patterns with Named Groups for parsing file names.
11. Type Hints, Generics & Static Safety (Lesson 42):
    • Apply explicit modern type annotations (X | Y, list[str], dict[str, Any]) throughout all functions and classes.
12. Metaprogramming, Closures & Decorators (Lessons 40-41):
    • Build function factories and 3-level configurable decorators with @functools.wraps.
13. Iterators & Generators (Lesson 39):
    • Implement generator functions streaming file archive lists lazily with $O(1)$ memory.
14. Full OOP Architecture (Lessons 32-38):
    • Define abstract base class BaseAutomationWorker(ABC) and concrete Data Classes AutomationJobRecord and EmailAudit.
    • Build composite manager OfficeAutomationOS composing storage drivers and custom context managers.
15. Observability & Fault Tolerance (Lessons 29-31):
    • Set up multi-handler logging to console and office_automation.log file.
    • Incorporate developer assertions (assert) verifying file non-nullability.
    • Define custom exception hierarchy (OfficeAutomationOSError, SpreadsheetGenerationError).
16. Context Managers & Persistence Layer (Lessons 27-30):
    • Use custom class-based context managers to manage temp directory cleanup.
    • Persist JSON payload backups to automation_db.json and export CSV reports to automation_audit.csv using pathlib.Path.
17. Nested Collections & Comprehensions (Lessons 21-26):
    • Maintain in-memory registry dictionaries mapping Job IDs to Data Class Instances.
    • Use List and Dictionary Comprehensions to clean and transform records.
18. 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.
19. 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().
20. Pattern Matching CLI Dispatcher (Lesson 12):
    • Process user CLI command tokens inside a match-case block with office automation match guards:
      • case ["ARCHIVE", "DIR", src_dir, dst_dir] → Execute directory scanning and ZIP compression.
      • case ["EXCEL", "GENERATE", filename] → Build styled Excel report with openpyxl.
      • case ["EMAIL", "SEND", to_addr, subj, attach] → Construct and send MIME email with attachment.
      • case ["EXPORT", "CSV"] → Export completed automation job history to CSV.
      • case ["EXIT" | "QUIT"] → Terminate session safely using a sentinel flag.
      • case _ → Output command error message.
21. 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.