pontalk: Explore Python's Hidden Treasures!

Productivity with a Chatbot: Building a Task Manager Bot

Written by

ken

in

Are you constantly juggling tasks, trying to remember what needs to be done next, and feeling overwhelmed by sticky notes or forgotten to-do lists? What if you had a friendly helper always available right where you chat to keep track of everything for you? That’s exactly what a task manager chatbot can do!

In this blog post, we’re going to dive into the exciting world of chatbots and productivity. We’ll build a simple, yet effective, task manager bot using Python. Don’t worry if you’re new to coding; we’ll use simple language and explain every step along the way. By the end, you’ll have a basic bot that can help you manage your daily tasks and a solid understanding of how these useful tools are created!

Why Use a Chatbot for Task Management?

You might be thinking, “Why a chatbot? I already have apps for that!” And you’re right, there are many excellent task management apps. However, chatbots offer a unique set of advantages:

  • Always Accessible: Chatbots live in the platforms you already use daily – your messaging apps, your console, or even your browser. This means your task list is always just a few keystrokes away.
  • Natural Language Interface: Instead of navigating complex menus, you can simply type commands like “add buy milk” or “list tasks.” It feels more like talking to an assistant.
  • Reduced Friction: The ease of interaction can encourage you to record tasks immediately, preventing those “I’ll remember that later” moments that often lead to forgotten duties.
  • Learning Opportunity: Building one yourself is a fantastic way to learn programming concepts in a practical and engaging manner!

What We’ll Build Today

To keep things simple and easy to understand for beginners, our task manager bot will have the following core functionalities:

  • Add a Task: You’ll be able to tell the bot to add a new item to your to-do list.
  • List All Tasks: The bot will show you all your pending and completed tasks.
  • Mark a Task as Complete: Once you finish a task, you can tell the bot to mark it as done.
  • Remove a Task: Sometimes tasks get cancelled, and you’ll want to remove them.
  • Exit: A way to gracefully stop the bot.

This is a great starting point for understanding the basic building blocks of more complex chatbots.

Tools We’ll Need

For this project, we’ll keep our tools minimal and focused:

  • Python: This is the programming language we’ll use. Python is known for its simplicity and readability, making it an excellent choice for beginners. If you don’t have Python installed, you can download it from python.org.
  • A Text Editor: You’ll need a program to write your code. Popular choices include VS Code, Sublime Text, Atom, or even a basic text editor like Notepad (Windows) or TextEdit (macOS).

We’ll be building a “console bot,” which means you’ll interact with it directly in your computer’s terminal or command prompt, rather than through a web interface or a messaging app. This simplifies the setup significantly and allows us to focus purely on the bot’s logic.

Let’s Get Coding!

It’s time to roll up our sleeves and start bringing our task manager bot to life!

Setting Up Your Environment

  1. Install Python: If you haven’t already, download and install Python from python.org. Make sure to check the box that says “Add Python to PATH” during installation if you’re on Windows, as this makes it easier to run Python commands from your terminal.
  2. Create a New File: Open your chosen text editor and create a new file. Save it as task_bot.py (or any other .py name you prefer). The .py extension tells your computer it’s a Python script.

Storing Our Tasks

First, we need a way to store our tasks. In Python, a list is a perfect data structure for this. A list is like a shopping list where you can add multiple items. Each item in our task list will be a dictionary. A dictionary is like a real-world dictionary where you have words (keys) and their definitions (values). For us, each task will have an id, a description, and a completed status.

We’ll also need a simple way to give each task a unique ID, so we’ll use a task_id_counter.

tasks = [] # This list will hold all our task dictionaries
task_id_counter = 1 # We'll use this to assign a unique ID to each new task

Adding a Task

Let’s write a function to add new tasks. A function is a block of organized, reusable code that performs a single, related action. It helps keep our code tidy and efficient.

def add_task(description):
    """Adds a new task to the tasks list."""
    global task_id_counter # 'global' keyword lets us modify the variable defined outside the function
    new_task = {
        'id': task_id_counter,
        'description': description,
        'completed': False # All new tasks start as not completed
    }
    tasks.append(new_task) # 'append' adds the new task dictionary to our 'tasks' list
    task_id_counter += 1 # Increment the counter for the next task
    print(f"Task '{description}' added with ID {new_task['id']}.")

Listing All Tasks

Next, we need a way to see all the tasks we’ve added. This function will go through our tasks list and print each one, along with its status.

def list_tasks():
    """Prints all tasks, showing their ID, description, and completion status."""
    if not tasks: # Check if the tasks list is empty
        print("No tasks found. Add some tasks to get started!")
        return # Exit the function if there are no tasks

    print("\n--- Your To-Do List ---")
    for task in tasks: # A 'for' loop iterates over each item in the 'tasks' list
        status = "✓" if task['completed'] else " " # '✓' for completed, ' ' for pending
        print(f"[{status}] ID: {task['id']} - {task['description']}")
    print("-----------------------\n")

Marking a Task as Complete

When you finish a task, you’ll want to mark it as done. This function will take a task ID, find the corresponding task in our list, and update its completed status.

def complete_task(task_id):
    """Marks a task as completed given its ID."""
    found = False
    for task in tasks:
        if task['id'] == task_id: # Check if the current task's ID matches the one we're looking for
            task['completed'] = True # Update the 'completed' status
            print(f"Task ID {task_id} ('{task['description']}') marked as complete.")
            found = True
            break # Exit the loop once the task is found and updated
    if not found:
        print(f"Task with ID {task_id} not found.")

Removing a Task

Sometimes a task is no longer relevant. This function will allow you to remove a task from the list using its ID.

def remove_task(task_id):
    """Removes a task from the list given its ID."""
    global tasks # We need to modify the global tasks list
    initial_length = len(tasks)
    # Create a new list containing only the tasks whose IDs do NOT match the one we want to remove
    tasks = [task for task in tasks if task['id'] != task_id]
    if len(tasks) < initial_length:
        print(f"Task with ID {task_id} removed.")
    else:
        print(f"Task with ID {task_id} not found.")

Putting It All Together: The Main Bot Loop

Now, let’s combine all these functions into a main loop that will run our bot. The while True: loop will keep the bot running until we explicitly tell it to stop. Inside the loop, we’ll prompt the user for commands and call the appropriate functions.

def main():
    """The main function to run our chatbot."""
    print("Welcome to your simple Task Manager Bot!")
    print("Type 'help' for available commands.")

    while True: # This loop will keep the bot running indefinitely until we exit
        command = input("Enter command: ").strip().lower() # 'input()' gets text from the user, '.strip()' removes extra spaces, '.lower()' converts to lowercase

        if command == 'help':
            print("\nAvailable commands:")
            print("  add <description>  - Add a new task (e.g., 'add Buy groceries')")
            print("  list               - Show all tasks")
            print("  complete <ID>      - Mark a task as complete (e.g., 'complete 1')")
            print("  remove <ID>        - Remove a task (e.g., 'remove 2')")
            print("  exit               - Quit the bot")
            print("-----------------------\n")
        elif command.startswith('add '): # Check if the command starts with 'add '
            description = command[4:] # Grab everything after 'add ' as the description
            if description:
                add_task(description)
            else:
                print("Please provide a description for the task. (e.g., 'add Read a book')")
        elif command == 'list':
            list_tasks()
        elif command.startswith('complete '):
            try:
                task_id = int(command[9:]) # Convert the ID part of the command to an integer
                complete_task(task_id)
            except ValueError: # Handle cases where the user doesn't enter a valid number
                print("Invalid task ID. Please enter a number after 'complete'. (e.g., 'complete 1')")
        elif command.startswith('remove '):
            try:
                task_id = int(command[7:])
                remove_task(task_id)
            except ValueError:
                print("Invalid task ID. Please enter a number after 'remove'. (e.g., 'remove 2')")
        elif command == 'exit':
            print("Exiting Task Manager Bot. Goodbye!")
            break # 'break' exits the 'while True' loop, ending the program
        else:
            print("Unknown command. Type 'help' for a list of commands.")

if __name__ == "__main__":
    main()

The Complete Code (task_bot.py)

Here’s all the code put together:

tasks = [] # This list will hold all our task dictionaries
task_id_counter = 1 # We'll use this to assign a unique ID to each new task

def add_task(description):
    """Adds a new task to the tasks list."""
    global task_id_counter
    new_task = {
        'id': task_id_counter,
        'description': description,
        'completed': False
    }
    tasks.append(new_task)
    task_id_counter += 1
    print(f"Task '{description}' added with ID {new_task['id']}.")

def list_tasks():
    """Prints all tasks, showing their ID, description, and completion status."""
    if not tasks:
        print("No tasks found. Add some tasks to get started!")
        return

    print("\n--- Your To-Do List ---")
    for task in tasks:
        status = "✓" if task['completed'] else " "
        print(f"[{status}] ID: {task['id']} - {task['description']}")
    print("-----------------------\n")

def complete_task(task_id):
    """Marks a task as completed given its ID."""
    found = False
    for task in tasks:
        if task['id'] == task_id:
            task['completed'] = True
            print(f"Task ID {task_id} ('{task['description']}') marked as complete.")
            found = True
            break
    if not found:
        print(f"Task with ID {task_id} not found.")

def remove_task(task_id):
    """Removes a task from the list given its ID."""
    global tasks
    initial_length = len(tasks)
    tasks = [task for task in tasks if task['id'] != task_id]
    if len(tasks) < initial_length:
        print(f"Task with ID {task_id} removed.")
    else:
        print(f"Task with ID {task_id} not found.")

def main():
    """The main function to run our chatbot."""
    print("Welcome to your simple Task Manager Bot!")
    print("Type 'help' for available commands.")

    while True:
        command = input("Enter command: ").strip().lower()

        if command == 'help':
            print("\nAvailable commands:")
            print("  add <description>  - Add a new task (e.g., 'add Buy groceries')")
            print("  list               - Show all tasks")
            print("  complete <ID>      - Mark a task as complete (e.g., 'complete 1')")
            print("  remove <ID>        - Remove a task (e.g., 'remove 2')")
            print("  exit               - Quit the bot")
            print("-----------------------\n")
        elif command.startswith('add '):
            description = command[4:]
            if description:
                add_task(description)
            else:
                print("Please provide a description for the task. (e.g., 'add Read a book')")
        elif command == 'list':
            list_tasks()
        elif command.startswith('complete '):
            try:
                task_id = int(command[9:])
                complete_task(task_id)
            except ValueError:
                print("Invalid task ID. Please enter a number after 'complete'. (e.g., 'complete 1')")
        elif command.startswith('remove '):
            try:
                task_id = int(command[7:])
                remove_task(task_id)
            except ValueError:
                print("Invalid task ID. Please enter a number after 'remove'. (e.g., 'remove 2')")
        elif command == 'exit':
            print("Exiting Task Manager Bot. Goodbye!")
            break
        else:
            print("Unknown command. Type 'help' for a list of commands.")

if __name__ == "__main__":
    main()

Testing Your Bot

To run your bot, open your terminal or command prompt, navigate to the directory where you saved task_bot.py, and type:

python task_bot.py

You should see the welcome message. Try interacting with it:

Welcome to your simple Task Manager Bot!
Type 'help' for available commands.
Enter command: add Buy groceries
Task 'Buy groceries' added with ID 1.
Enter command: add Call mom
Task 'Call mom' added with ID 2.
Enter command: list

--- Your To-Do List ---
[ ] ID: 1 - Buy groceries
[ ] ID: 2 - Call mom
-----------------------

Enter command: complete 1
Task ID 1 ('Buy groceries') marked as complete.
Enter command: list

--- Your To-Do List ---
[✓] ID: 1 - Buy groceries
[ ] ID: 2 - Call mom
-----------------------

Enter command: remove 2
Task with ID 2 removed.
Enter command: list

--- Your To-Do List ---
[✓] ID: 1 - Buy groceries
-----------------------

Enter command: exit
Exiting Task Manager Bot. Goodbye!

Congratulations! You’ve just built your very own task manager chatbot.

Next Steps and Enhancements

This simple console bot is just the beginning! Here are some ideas for how you can expand and improve it:

  • Persistent Storage: Right now, your tasks disappear every time you close the bot. You could save them to a file (like a .txt or .json file) or a simple database (like SQLite) so they’re remembered for next time.
  • Due Dates and Priorities: Add fields for a due date or a priority level to your tasks.
  • More Sophisticated Commands: Implement more complex commands, like “edit task ” to change a task’s description.
  • Integrate with Real Chat Platforms: Use libraries like python-telegram-bot, discord.py, or Slack Bolt to turn your console bot into a bot that works within your favorite messaging apps.
  • Natural Language Processing (NLP): For a more advanced challenge, explore NLP libraries (like NLTK or SpaCy) to allow your bot to understand more natural phrases, such as “remind me to buy milk tomorrow morning.”

Conclusion

You’ve taken a fantastic step into the world of programming and productivity! By building this task manager chatbot, you’ve learned fundamental Python concepts like lists, dictionaries, functions, loops, and conditional statements, all while creating a practical tool. Chatbots are powerful applications that can simplify many aspects of our digital lives, and now you have the foundational skills to build even more amazing things. Keep experimenting, keep learning, and happy coding!

Comments

Leave a Reply

More posts