chatter-py 1.0.1

A lightweight Python framework for building chatbots.

Chatter

Welcome to Chatter!

Chatter is a framework with the goal of allowing you to quickly and easily create chatbots. It hides away the things you want to just work, exposing a simple API, so that you can focus on writing your custom features and delivering a working chatbot.

Take a look:

from chatter_py import ChatClient, Feature, Bot, Message
from typing import Any


# Define your feature
class Echo(Feature):
    def receive(self, message):
        self.send_to_chat(message)


# Write a handler for your chat client, for example:
class MyChatClient(ChatClient):
    def __init__(self):
        self.chat_client_connection = Any

    def on_chat_message(self, message: dict):
        """Receive your chat messages and convert them to bot friendly messages"""
        bot_message = Message(text=message["text"], room=message["room_id"])
        self.send_to_bot(bot_message)

    def start_listening(self) -> None:
        """connect to your chat client"""
        self.chat_client_connection.register_callback(self.on_chat_message)
        self.chat_client_connection.start_listening()

    def send_to_client(self, message):
        """Format your bot messages and send them off to your chat client"""
        text = "<p>" + " ".join(message.text) + "</p>"
        self.chat_client_connection.send(text)


def main():
    # Let Chatter put it all together
    Bot(MyChatClient(), [Echo]).start()


if __name__ == '__main__':
    # Start your bot!
    main()

Chatter encourages you to separate concerns by keeping your chat client specific message transformations in your ChatClient classes and letting all your Feature classes handle standardised Messages. This:

• Makes your code more testable
• Makes your bot super portable - being able to handle a new chat client is as simple as creating a new ChatClient subclass and writing your custom logic for transforming messages between Bot and Presentation format.

You could even use a command-line frontend for testing your bot's logic:

from chatter_py import ChatClient, Message


class CommandLine(ChatClient):
    def send_to_client(self, message: Message):
        print("Chatter-bot: " + " ".join(message.text))

    def start_listening(self) -> None:
        while True:
            input_message = input("You: ")
            message_to_bot = Message(text=input_message.split(" "), room="")
            self.send_to_bot(message_to_bot)

Now every time you write a new chat client class, all you have to focus on testing is given a Bot message, you receive the correct chat message, and vice versa - simple!