10xdev Book: Programming from Zero to Pro with Python

# File: task.py
import datetime
from typing import Self # For type hinting __str__ method return

class Task:
    """Represents a single task with title, status, and creation time."""

    def __init__(self, title: str, is_done: bool = False):
        """Initializes a new task."""
        if not title: # Basic validation
            raise ValueError("Task title cannot be empty.")
        self.title: str = title
        self.is_done: bool = is_done
        self.created_at: datetime.datetime = datetime.datetime.now()

    def mark_as_done(self):
        """Marks the task as completed."""
        self.is_done = True

    def __str__(self) -> str:
        """Returns a user-friendly string representation of the task."""
        status_icon = "✅" if self.is_done else "🔘"
        # Use a simpler date format
        formatted_date = self.created_at.strftime("%Y-%m-%d")
        return f"[{status_icon}] {self.title} (Added: {formatted_date})"

    # Optional: For debugging or more detailed representation
    def __repr__(self) -> str:
        return f"Task(title='{self.title}', is_done={self.is_done}, created_at='{self.created_at.isoformat()}')"

# File: storage.py
import json
import datetime
from pathlib import Path
from typing import List, Dict, Any # For type hints
from task import Task # Import our Task class

# Define storage file path using pathlib
STORAGE_FILENAME = "tasks.json"
STORAGE_PATH = Path(STORAGE_FILENAME)

# Type alias for clarity
TaskDict = Dict[str, Any]
TaskList = List[Task]

def save_tasks(tasks: TaskList):
    """Serializes a list of Task objects to a JSON file."""
    list_to_save: List[TaskDict] = []
    for task_obj in tasks:
        task_dict: TaskDict = {
            "title": task_obj.title,
            "is_done": task_obj.is_done,
            "created_at": task_obj.created_at.isoformat() # Convert datetime to string
        }
        list_to_save.append(task_dict)

    try:
        # Use Path object's write_text method with json.dumps for more control
        json_string = json.dumps(list_to_save, indent=4, ensure_ascii=False)
        STORAGE_PATH.write_text(json_string, encoding='utf-8')
    except IOError as e:
        print(f"Error: Could not save tasks to {STORAGE_PATH}: {e}")
    except TypeError as e:
        print(f"Error: Could not serialize tasks: {e}")


def load_tasks() -> TaskList:
    """Deserializes tasks from the JSON file into a list of Task objects."""
    if not STORAGE_PATH.exists():
        return [] # Return empty list if file doesn't exist

    try:
        json_string = STORAGE_PATH.read_text(encoding='utf-8')
        # Handle empty file case
        if not json_string.strip():
            return []
        list_of_dicts: List[TaskDict] = json.loads(json_string)

        loaded_tasks: TaskList = []
        for task_dict in list_of_dicts:
            try:
                # Recreate Task object
                task_obj = Task(task_dict['title'], task_dict.get('is_done', False)) # Use .get for safety
                # Convert date string back to datetime object
                task_obj.created_at = datetime.datetime.fromisoformat(task_dict['created_at'])
                loaded_tasks.append(task_obj)
            except (KeyError, ValueError, TypeError) as e:
                 print(f"Warning: Skipping invalid task data: {task_dict}. Error: {e}")
        return loaded_tasks

    except (json.JSONDecodeError, IOError) as e:
        print(f"Error: Could not load or parse tasks from {STORAGE_PATH}: {e}")
        print("Starting with an empty task list.")
        return [] # Return empty list on error

# File: main.py
from storage import save_tasks, load_tasks
from task import Task
from typing import List

# Type alias for the list of tasks
TaskList = List[Task]

def display_menu():
    """Prints the main menu options."""
    print("\n--- Python To-Do App ---")
    print("1. View Tasks")
    print("2. Add Task")
    print("3. Mark Task Done")
    print("4. Delete Task")
    print("5. Exit")

def display_tasks(tasks: TaskList):
    """Displays all tasks, numbered."""
    print("\n--- Your Tasks ---")
    if not tasks:
        print("No tasks yet. Add one!")
    else:
        for i, task in enumerate(tasks, start=1):
            print(f"{i}. {task}") # Relies on Task.__str__

def get_task_index(prompt: str, max_index: int) -> int | None:
    """Safely gets a valid 1-based task index from the user."""
    while True:
        try:
            num_str = input(prompt).strip()
            if not num_str: # Handle empty input
                 return None # Allow cancelling
            task_num = int(num_str)
            if 1 <= task_num <= max_index:
                return task_num - 1 # Convert to 0-based index
            else:
                print(f"Invalid number. Please enter between 1 and {max_index}.")
        except ValueError:
            print("Invalid input. Please enter a number.")


def main():
    """Main function to run the application."""
    tasks: TaskList = load_tasks() # Load tasks at start

    while True:
        display_menu()
        choice = input("Enter choice (1-5): ").strip()

        if choice == '1': # View
            display_tasks(tasks)

        elif choice == '2': # Add
            title = input("Enter new task title: ").strip()
            if title:
                try:
                    tasks.append(Task(title))
                    save_tasks(tasks)
                    print("Task added.")
                except ValueError as e: # Catch title validation error from Task.__init__
                    print(f"Error: {e}")
            else:
                print("Task title cannot be empty.")

        elif choice == '3': # Mark Done
            display_tasks(tasks)
            if tasks:
                index = get_task_index("Enter number of task to mark done (or Enter to cancel): ", len(tasks))
                if index is not None:
                    tasks[index].mark_as_done()
                    save_tasks(tasks)
                    print("Task marked as done.")
            else:
                 print("No tasks to mark.")

        elif choice == '4': # Delete
            display_tasks(tasks)
            if tasks:
                index = get_task_index("Enter number of task to delete (or Enter to cancel): ", len(tasks))
                if index is not None:
                    removed_task = tasks.pop(index)
                    save_tasks(tasks)
                    print(f"Task '{removed_task.title}' deleted.")
            else:
                 print("No tasks to delete.")


        elif choice == '5': # Exit
            print("Saving tasks and exiting. Goodbye!")
            save_tasks(tasks) # Ensure saving on exit too
            break

        else:
            print("Invalid choice. Please enter a number between 1 and 5.")

# --- Run the main application ---
if __name__ == "__main__":
    # Setup uv environment first if needed:
    # uv init . (if first time)
    # uv sync (to install dependencies if any were added)
    main()