Build a Simple CLI Task Manager in Python 🚀

In this comprehensive guide, we’ll walk you through building a command-line interface (CLI) task manager using Python. A task manager is an essential tool for organizing your daily life, projects, or work. By building your own, you’ll not only gain a practical tool but also solidify your understanding of Python fundamentals, file handling, and user input/output.

Why Build a CLI Task Manager?

Building a CLI task manager offers several benefits:

• Personalization: Tailor the task manager to your specific needs and preferences.
• Learning: Hands-on experience with Python programming, file I/O, and CLI interaction.
• Efficiency: A lightweight and fast alternative to GUI-based task managers.
• Customization: Easily extend the functionality with features like reminders, priority levels, and project organization.

Target Audience

This tutorial is designed for individuals who:

• Have a basic understanding of Python programming.
• Are familiar with command-line interfaces.
• Want to learn how to build practical applications with Python.
• Are looking for a customizable task management solution.

Prerequisites

Before we begin, ensure you have the following:

• Python Installed: Python 3.6 or higher is recommended. You can download it from python.org.
• Text Editor: A code editor of your choice (e.g., VS Code, Sublime Text, Atom).
• Basic Python Knowledge: Familiarity with variables, data types, loops, and functions is expected.

Core Features of Our Task Manager

Our task manager will include the following core features:

• Adding Tasks: Add new tasks with descriptions.
• Listing Tasks: Display all tasks with their status (e.g., pending, completed).
• Marking Tasks as Complete: Change the status of a task to “completed.”
• Deleting Tasks: Remove tasks from the list.
• Saving and Loading Tasks: Persist tasks to a file so they are available across sessions.

Project Setup

Let’s begin by setting up our project structure:

1. Create a Directory: Create a directory for your project (e.g., task_manager).
2. Create a Python File: Inside the directory, create a Python file named task_manager.py.
3. Optional: Create a tasks.txt file: This file will store the tasks that are added to the task manager

Step-by-Step Implementation

1. Importing Necessary Modules

We’ll start by importing the os module, which will be useful for checking if our data file exists.

“`python

import os

“`

2. Defining the Task Class

We’ll define a Task class to represent each task in our task manager. This class will hold the task description and its completion status.

“`python

class Task:

def __init__(self, description, completed=False):

self.description = description

self.completed = completed

def __str__(self):

return f”[{‘X’ if self.completed else ‘ ‘}] {self.description}”

“`

• The __init__ method initializes a new Task object with a description and an optional completion status (defaulting to False).
• The __str__ method provides a string representation of the task, making it easy to print. It shows an ‘X’ if the task is completed, and a space otherwise.

3. Loading and Saving Tasks to a File

To persist tasks between sessions, we’ll implement functions to load tasks from a file and save them back to the file.

“`python

def load_tasks(filename=”tasks.txt”):

tasks = []

if os.path.exists(filename):

with open(filename, “r”) as f:

for line in f:

completed, description = line.strip().split(“|”, 1)

tasks.append(Task(description, completed == “True”))

return tasks

def save_tasks(tasks, filename=”tasks.txt”):

with open(filename, “w”) as f:

for task in tasks:

f.write(f”{task.completed}|{task.description}\n”)

“`

• The load_tasks function reads tasks from a file (defaulting to “tasks.txt”). It splits each line into completion status and description, and creates a Task object for each line.
• The save_tasks function writes the current list of tasks to the file. Each task is written as “completion_status|description”.

4. Implementing Task Management Functions

Now, let’s implement the core functions to add, list, mark complete, and delete tasks.

“`python

def add_task(tasks, description):

tasks.append(Task(description))

print(f”Task added: {description}”)

def list_tasks(tasks):

if not tasks:

print(“No tasks in the list.”)

return

for index, task in enumerate(tasks):

print(f”{index + 1}. {task}”)

def complete_task(tasks, index):

if 1 <= index <= len(tasks):

tasks[index – 1].completed = True

print(f”Task {index} marked as complete.”)

else:

print(“Invalid task index.”)

def delete_task(tasks, index):

if 1 <= index <= len(tasks):

deleted_task = tasks.pop(index – 1)

print(f”Task ‘{deleted_task.description}’ deleted.”)

else:

print(“Invalid task index.”)

“`

• add_task: Creates a new `Task` object and appends it to the list of tasks.
• list_tasks: Iterates through the list of tasks and prints each task with its index. If the list is empty, it prints a message indicating that.
• complete_task: Marks a task as complete based on its index in the list. It checks for valid index before modifying the task.
• delete_task: Removes a task from the list based on its index. It also checks for a valid index.

5. Implementing the Main Function and Command-Line Interface

The main function will handle user input and call the appropriate functions based on the user’s commands.

“`python

def main():

tasks = load_tasks()

while True:

print(“\nTask Manager Menu:”)

print(“1. Add task”)

print(“2. List tasks”)

print(“3. Complete task”)

print(“4. Delete task”)

print(“5. Save and Exit”)

choice = input(“Enter your choice: “)

if choice == “1”:

description = input(“Enter task description: “)

add_task(tasks, description)

elif choice == “2”:

list_tasks(tasks)

elif choice == “3”:

list_tasks(tasks)

try:

index = int(input(“Enter the index of the task to complete: “))

complete_task(tasks, index)

except ValueError:

print(“Invalid input. Please enter a number.”)

elif choice == “4”:

list_tasks(tasks)

try:

index = int(input(“Enter the index of the task to delete: “))

delete_task(tasks, index)

except ValueError:

print(“Invalid input. Please enter a number.”)

elif choice == “5”:

save_tasks(tasks)

print(“Tasks saved. Exiting…”)

break

else:

print(“Invalid choice. Please try again.”)

if __name__ == “__main__”:

main()

“`

• The main function loads tasks from the file at the beginning and presents a menu to the user.
• It uses a while loop to continuously prompt the user for input until the user chooses to exit.
• Based on the user’s choice, it calls the appropriate functions (add_task, list_tasks, complete_task, delete_task).
• It saves the tasks to the file before exiting.
• The if __name__ == "__main__": block ensures that the main function is called only when the script is executed directly (not when it’s imported as a module).

6. Complete Code

“`python

import os

class Task:

def __init__(self, description, completed=False):

self.description = description

self.completed = completed

def __str__(self):

return f”[{‘X’ if self.completed else ‘ ‘}] {self.description}”

def load_tasks(filename=”tasks.txt”):

tasks = []

if os.path.exists(filename):

with open(filename, “r”) as f:

for line in f:

completed, description = line.strip().split(“|”, 1)

tasks.append(Task(description, completed == “True”))

return tasks

def save_tasks(tasks, filename=”tasks.txt”):

with open(filename, “w”) as f:

for task in tasks:

f.write(f”{task.completed}|{task.description}\n”)

def add_task(tasks, description):

tasks.append(Task(description))

print(f”Task added: {description}”)

def list_tasks(tasks):

if not tasks:

print(“No tasks in the list.”)

return

for index, task in enumerate(tasks):

print(f”{index + 1}. {task}”)

def complete_task(tasks, index):

if 1 <= index <= len(tasks):

tasks[index – 1].completed = True

print(f”Task {index} marked as complete.”)

else:

print(“Invalid task index.”)

def delete_task(tasks, index):

if 1 <= index <= len(tasks):

deleted_task = tasks.pop(index – 1)

print(f”Task ‘{deleted_task.description}’ deleted.”)

else:

print(“Invalid task index.”)

def main():

tasks = load_tasks()

while True:

print(“\nTask Manager Menu:”)

print(“1. Add task”)

print(“2. List tasks”)

print(“3. Complete task”)

print(“4. Delete task”)

print(“5. Save and Exit”)

choice = input(“Enter your choice: “)

if choice == “1”:

description = input(“Enter task description: “)

add_task(tasks, description)

elif choice == “2”:

list_tasks(tasks)

elif choice == “3”:

list_tasks(tasks)

try:

index = int(input(“Enter the index of the task to complete: “))

complete_task(tasks, index)

except ValueError:

print(“Invalid input. Please enter a number.”)

elif choice == “4”:

list_tasks(tasks)

try:

index = int(input(“Enter the index of the task to delete: “))

delete_task(tasks, index)

except ValueError:

print(“Invalid input. Please enter a number.”)

elif choice == “5”:

save_tasks(tasks)

print(“Tasks saved. Exiting…”)

break

else:

print(“Invalid choice. Please try again.”)

if __name__ == “__main__”:

main()

“`

7. Running the Task Manager

Save the code in task_manager.py and run it from your terminal:

“`bash

python task_manager.py

“`

You should see the task manager menu. Follow the prompts to add, list, complete, or delete tasks.

Enhancements and Further Development

Here are some ideas for enhancements and further development:

• Priority Levels: Add priority levels to tasks (e.g., high, medium, low).
• Due Dates: Allow users to set due dates for tasks.
• Reminders: Implement reminders using a scheduling library like schedule.
• GUI Interface: Create a graphical user interface using a library like Tkinter or PyQt.
• Search Functionality: Implement a search feature to find tasks based on keywords.
• Project Management: Organize tasks into projects or categories.
• Cloud Syncing: Synchronize tasks across multiple devices using a cloud service.
• Error Handling: Improve error handling, for example when the `tasks.txt` file is corrupted.
• Testing: Add unit tests to verify the correctness of the task manager.

Best Practices for CLI Applications

Here are some best practices to keep in mind when developing CLI applications:

• User-Friendly Interface: Provide clear instructions and helpful messages.
• Input Validation: Validate user input to prevent errors.
• Error Handling: Handle exceptions gracefully and provide informative error messages.
• Modularity: Structure your code into reusable functions and classes.
• Documentation: Document your code with comments and docstrings.
• Testing: Write unit tests to ensure the reliability of your application.
• Configuration: Allow users to configure the application through command-line arguments or configuration files.
• Help Messages: Implement a help command to provide usage information.
• Readability: Follow PEP 8 guidelines for Python code style.

Example Usage Scenarios

Here are a few scenarios demonstrating how to use the task manager:

1. Adding a Task:
   • Enter 1 to choose “Add task.”
   • Enter a description like “Grocery shopping.”
2. Listing Tasks:
   • Enter 2 to choose “List tasks.”
   • The task “Grocery shopping” will be displayed with its index.
3. Marking a Task as Complete:
   • Enter 3 to choose “Complete task.”
   • Enter the index of the task (e.g., 1).
   • Task 1 will be marked as complete.
4. Deleting a Task:
   • Enter 4 to choose “Delete task.”
   • Enter the index of the task (e.g., 1).
   • Task 1 will be deleted.
5. Saving and Exiting:
   • Enter 5 to choose “Save and Exit.”
   • The tasks will be saved to the tasks.txt file, and the application will exit.

Common Issues and Troubleshooting

Here are some common issues you might encounter and how to troubleshoot them:

• File Not Found Error:
  • Ensure that the tasks.txt file exists in the same directory as your script, or update the filename in the load_tasks and save_tasks functions.
• IndexError:
  • This usually occurs when you enter an invalid task index. Double-check the index you’re entering, and make sure it’s within the valid range of task indices displayed when listing tasks.
• ValueError:
  • This can occur if you enter non-numeric input when the program expects a number (e.g., when entering a task index). Make sure you are entering valid integer numbers.
• Tasks Not Saving:
  • Verify that the script has write permissions to the directory.
• Tasks Loading Incorrectly:
  • Check the formatting of your tasks.txt file. Make sure each line is in the format “completion_status|description”. Corrupted files can cause loading errors.

Alternative Approaches and Libraries

While this tutorial covers a basic implementation, there are alternative approaches and libraries you can use to enhance your task manager:

• Argparse: Use the argparse module for more sophisticated command-line argument parsing. This allows you to create more complex commands and options.
• Click: Click is another popular library for building CLI applications, offering a more declarative approach to defining commands.
• Typer: Typer is a modern CLI framework based on Python 3.6+ and designed for ease of use and automatic completion.
• Database Storage: Instead of a text file, consider using a database like SQLite for storing tasks, especially if you plan to add more complex features.
• Object-Relational Mapping (ORM): Use an ORM like SQLAlchemy to interact with the database in a more object-oriented way.

Real-World Applications and Use Cases

A CLI task manager can be used in various real-world scenarios:

• Personal Productivity: Managing personal to-do lists and daily tasks.
• Project Management: Tracking tasks for small projects.
• Software Development: Organizing development tasks and bug fixes.
• System Administration: Automating system administration tasks.
• Education: Learning and practicing Python programming skills.

Conclusion

Congratulations! You’ve successfully built a simple CLI task manager using Python. This project has provided you with hands-on experience in Python programming, file handling, and CLI interaction. By understanding the fundamentals covered in this tutorial, you can now customize and extend your task manager to suit your specific needs. Remember to explore the enhancements and alternative approaches mentioned above to further improve your application.

Keep practicing and experimenting with Python to build more exciting and useful applications!

Additional Resources

• Python Documentation
• Real Python
• Python Course