https://github.com/nickjfenton/chatter
A lightweight Python framework for building chatbots.
https://github.com/nickjfenton/chatter
chatbot framework python
Last synced: 3 months ago
JSON representation
A lightweight Python framework for building chatbots.
- Host: GitHub
- URL: https://github.com/nickjfenton/chatter
- Owner: nickjfenton
- License: mit
- Created: 2021-10-24T14:02:38.000Z (over 4 years ago)
- Default Branch: master
- Last Pushed: 2022-01-19T00:26:57.000Z (about 4 years ago)
- Last Synced: 2025-09-23T20:47:25.811Z (6 months ago)
- Topics: chatbot, framework, python
- Language: Python
- Homepage:
- Size: 57.6 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.txt
Awesome Lists containing this project
README
# Chatter
[](https://codecov.io/gh/nickjfenton/chatter)
[](https://chatter-py.readthedocs.io/en/latest/?badge=latest)
## 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:
```python
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 = "
" + " ".join(message.text) + "
"
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:
```python
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!