Implementing Chat Communication Outside the Browser Using Python Notebooks

Lessons learnt building a medical chatbot in Python - TIB AV-Portal

In today's interconnected world, real-time communication tools like chat applications have become essential for collaboration, education, and personal interactions. While many chat systems operate within web browsers, there are scenarios where integrating chat functionality directly into Python Jupyter Notebooks is advantageous. This integration facilitates seamless interaction between users and computational resources, enabling dynamic data analysis, collaborative coding, and interactive learning experiences. This comprehensive guide explores various methods to implement chat communication outside the browser using Python notebooks, leveraging tools like WebSockets, socket programming, messaging APIs, and interactive widgets.

Overview of Chat Communication in Python Notebooks

Python Jupyter Notebooks are interactive environments widely used for data analysis, scientific research, and educational purposes. Integrating chat functionality within these notebooks can enhance collaboration and provide real-time feedback mechanisms. Whether for debugging, brainstorming, or instructional purposes, having an embedded chat system can significantly improve the user experience. This guide delves into multiple approaches to achieve this functionality, ensuring flexibility and scalability based on specific requirements.

Setting Up the Environment

Prerequisites

Python 3.6+: Ensure Python is installed. Download it from python.org.
Jupyter Notebook: Install Jupyter if not already present.
pip install jupyter
Required Libraries: Install necessary Python libraries using pip.
pip install websockets asyncio nest_asyncio ipywidgets python-telegram-bot

Launching Jupyter Notebook

Start Jupyter Notebook by executing the following command in your terminal:

jupyter notebook

This command opens the Jupyter interface in your default web browser, providing an accessible environment to develop and run Python code interactively.

Implementing Chat Using WebSockets

WebSockets provide a robust solution for real-time, bidirectional communication between clients and servers. Implementing a chat system using WebSockets within a Python notebook involves setting up a WebSocket server and connecting clients (notebooks) to it.

Setting Up a WebSocket Server

Creating a WebSocket server allows multiple clients to connect and communicate in real-time. Below is a step-by-step guide to setting up the server:

Server Code

Create a new Python cell in your Jupyter Notebook and insert the following code to initialize the WebSocket server:

import asyncio import websockets from collections import defaultdict import nest_asyncio # Apply nest_asyncio to allow nested event loops in Jupyter nest_asyncio.apply() connected = defaultdict(set) # Dictionary to hold room names and their connected clients async def broadcast(room, message): """ Sends a message to all clients in the specified room. """ if room in connected: websockets_to_remove = set() for ws in connected[room]: if ws.closed: websockets_to_remove.add(ws) continue try: await ws.send(message) except: websockets_to_remove.add(ws) # Remove closed or errored websockets for ws in websockets_to_remove: connected[room].remove(ws) async def handler(websocket, path): """ Handles incoming WebSocket connections. Expects the first message to be the room name. """ room = await websocket.recv() connected[room].add(websocket) print(f"New connection in room: {room}") await broadcast(room, f"A new user has joined the room: {room}") try: async for message in websocket: print(f"Message from room {room}: {message}") await broadcast(room, message) except websockets.ConnectionClosed: print(f"Connection closed in room: {room}") finally: connected[room].remove(websocket) await broadcast(room, f"A user has left the room: {room}") async def start_server(): """ Starts the WebSocket server. """ async with websockets.serve(handler, "localhost", 12345): print("WebSocket server started on ws://localhost:12345") await asyncio.Future() # Run forever # Start the server as a background task server_task = asyncio.create_task(start_server())

Executing this cell initializes the WebSocket server, listening on localhost at port 12345. The server manages multiple chat rooms, allowing clients to join specific rooms and engage in conversations.

Connecting to the WebSocket Server from Jupyter Notebook

To enable communication, clients (Jupyter notebooks) must connect to the WebSocket server. Below is the client-side implementation:

Client Code with Command-Line Interface

Insert the following code into a new Jupyter notebook cell to create a client that connects to the WebSocket server:

import asyncio import websockets import threading async def chat_client(room): uri = "ws://localhost:12345" async with websockets.connect(uri) as websocket: await websocket.send(room) print(f"Connected to room: {room}") async def send_messages(): while True: message = await asyncio.get_event_loop().run_in_executor(None, input) if message.lower() == 'exit': await websocket.close() print("Disconnected from chat.") break await websocket.send(f"User: {message}") async def receive_messages(): try: async for message in websocket: print(f"\n{message}") except websockets.ConnectionClosed: print("Connection closed by the server.") await asyncio.gather(send_messages(), receive_messages()) def start_chat(): room = input("Enter room name to join: ") asyncio.run(chat_client(room)) # Run the client in a separate thread to avoid blocking the notebook client_thread = threading.Thread(target=start_chat) client_thread.start()

Upon executing this cell, you'll be prompted to enter a room name (e.g., room1). Once connected, you can send and receive messages within that room. To exit the chat, type exit.

Enhancing the Client with a GUI

For a more user-friendly experience, you can create a graphical user interface (GUI) using tkinter. Here's how:

import tkinter as tk from tkinter import scrolledtext import asyncio import websockets import threading import nest_asyncio nest_asyncio.apply() class ChatClientGUI: def __init__(self, master, room): self.master = master self.master.title(f"Chat Room: {room}") self.chat_display = scrolledtext.ScrolledText(master, state='disabled') self.chat_display.grid(row=0, column=0, columnspan=2, padx=10, pady=10) self.message_entry = tk.Entry(master, width=50) self.message_entry.grid(row=1, column=0, padx=10, pady=(0,10)) self.message_entry.bind("", self.send_message) self.send_button = tk.Button(master, text="Send", command=self.send_message) self.send_button.grid(row=1, column=1, padx=10, pady=(0,10)) self.room = room self.uri = "ws://localhost:12345" self.loop = asyncio.new_event_loop() threading.Thread(target=self.start_loop, daemon=True).start() self.loop.call_soon_threadsafe(asyncio.create_task, self.run()) def start_loop(self): asyncio.set_event_loop(self.loop) self.loop.run_forever() async def run(self): async with websockets.connect(self.uri) as websocket: await websocket.send(self.room) self.display_message(f"Connected to room: {self.room}") async def send_messages(): while True: await asyncio.sleep(0.1) if hasattr(self, 'last_message'): message = self.last_message del self.last_message if message.lower() == 'exit': await websocket.close() self.master.quit() break await websocket.send(f"User: {message}") async def receive_messages(): try: async for message in websocket: self.display_message(message) except websockets.ConnectionClosed: self.display_message("Disconnected from server.") await asyncio.gather(send_messages(), receive_messages()) def send_message(self, event=None): message = self.message_entry.get() if message: self.last_message = message self.message_entry.delete(0, tk.END) def display_message(self, message): self.chat_display.config(state='normal') self.chat_display.insert(tk.END, message + '\n') self.chat_display.config(state='disabled') def open_chat_gui(): room = input("Enter room name to join: ") root = tk.Tk() gui = ChatClientGUI(root, room) root.mainloop() # Start the GUI client in a separate thread gui_thread = threading.Thread(target=open_chat_gui) gui_thread.start()

Executing this cell prompts for a room name and launches a GUI window where you can send and receive messages. This approach provides a more intuitive interface compared to the command-line client.

Utilizing the ChatGPT Jupyter Extension

The ChatGPT Jupyter extension allows users to interact with OpenAI's ChatGPT directly within Jupyter Notebooks. This integration is particularly useful for generating code snippets, debugging, or obtaining explanations without leaving the notebook environment.

Installing the ChatGPT Jupyter Extension

To install the extension, follow these steps:

Install via Chrome Web Store: Visit the Chrome Web Store and search for the ChatGPT Jupyter extension. Install it following the provided instructions.
Manual Installation: Clone the repository from GitHub and install it manually using pip.

Setting Up the Extension

After installation, establish a login session with OpenAI's ChatGPT service:

Open your Jupyter Notebook.
The extension will prompt you to sign in if an existing session isn't detected.
Once authenticated, the extension is ready to process ChatGPT prompts.

Creating and Sending ChatGPT Prompts

To utilize the extension for generating chat responses:

Create a Prompt Cell: In your notebook, create a markdown cell and start with ##### chat followed by the thread name (optional).
##### chat: My First ChatGPT Query How to write a Python function to calculate the sum of two numbers?
Send the Prompt: Press SHIFT+ENTER within the markdown cell. The extension processes the prompt and formats the response.
The generated code will appear in a separate code cell, ready for execution.
Execute the Code: Run the generated code cell to perform the desired action, such as calculating the sum of two numbers.

Example Workflow

Here's a simplified example showcasing the interaction:

Create a Markdown Cell:
##### chat: Sum Function Write a Python function to calculate the sum of two numbers.
Send the Prompt: Press SHIFT+ENTER.
Generated Code:
def sum_numbers(a, b): return a + b
Run the Code: Execute the code cell to define the function.
Now, you can use sum_numbers(5, 7) to obtain the result 12.

This workflow integrates ChatGPT directly into your Jupyter Notebook, enhancing interactive coding and development tasks.

Alternative Methods Using Socket Programming

Beyond WebSockets, traditional socket programming with threading offers a flexible way to implement chat communication. This approach involves creating server and client scripts that handle network connections and message broadcasting.

Basic Implementation Using Sockets

Server Script (server.py)

Create a new Python script named server.py with the following content:

import socket import threading HOST = '127.0.0.1' # localhost PORT = 55555 server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.bind((HOST, PORT)) server.listen() clients = [] nicknames = [] def broadcast(message): for client in clients: client.send(message) def handle(client): while True: try: message = client.recv(1024) broadcast(message) except: index = clients.index(client) clients.remove(client) client.close() nickname = nicknames[index] nicknames.remove(nickname) broadcast(f'{nickname} left the chat!'.encode('utf-8')) break def receive(): while True: client, address = server.accept() print(f"Connected with {str(address)}") client.send('NICK'.encode('utf-8')) nickname = client.recv(1024).decode('utf-8') nicknames.append(nickname) clients.append(client) print(f'Nickname of the client is {nickname}!') broadcast(f'{nickname} joined the chat!'.encode('utf-8')) client.send('Connected to the server!'.encode('utf-8')) thread = threading.Thread(target=handle, args=(client,)) thread.start() print("Server is listening...") receive()

Client Script (client.py)

Create another Python script named client.py with the following content:

import socket import threading nickname = input("Choose a nickname: ") client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(('127.0.0.1', 55555)) def receive(): while True: try: message = client.recv(1024).decode('utf-8') if message == 'NICK': client.send(nickname.encode('utf-8')) else: print(message) except: print("An error occurred!") client.close() break def write(): while True: message = f'{nickname}: {input("")}' client.send(message.encode('utf-8')) receive_thread = threading.Thread(target=receive) receive_thread.start() write_thread = threading.Thread(target=write) write_thread.start()

Running the Server and Client

Start the Server:
Run the server.py script in a terminal:

python server.py

You should see:

Server is listening...
Start Clients:
Open separate terminals for each client and run the client.py script:

python client.py

Enter a unique nickname when prompted.
Chat Interaction:
Clients can now send and receive messages in real-time. Messages are broadcasted to all connected clients.

Integrating with Messaging APIs

Leveraging existing messaging platforms like Telegram can simplify the implementation of chat communication. These platforms provide robust APIs that can be integrated into Python notebooks, enabling seamless interaction without building the entire infrastructure from scratch.

Using Telegram API

Telegram offers a powerful Bot API that allows developers to create bots capable of sending and receiving messages. Here's how to integrate a Telegram bot with your Python notebook:

Create a Telegram Bot:
Use the Telegram app to interact with BotFather and create a new bot. Note the BOT_TOKEN provided.
Install the python-telegram-bot Library:
pip install python-telegram-bot
Implement the Bot in Jupyter Notebook:
Insert the following code into a new notebook cell:

from telegram.ext import Updater, CommandHandler, MessageHandler, Filters TOKEN = "your-telegram-bot-token" def start(update, context): update.message.reply_text("Hi! Send me a message.") def echo(update, context): update.message.reply_text(update.message.text) updater = Updater(TOKEN, use_context=True) dp = updater.dispatcher dp.add_handler(CommandHandler("start", start)) dp.add_handler(MessageHandler(Filters.text & ~Filters.command, echo)) updater.start_polling() updater.idle()

Replace your-telegram-bot-token with the actual token obtained from BotFather.
Interact with the Bot:
Send messages to your Telegram bot, and it will echo them back. This simple setup can be expanded to include more complex functionalities like broadcasting messages to the notebook or handling specific commands.

Using Telegram bots offers a straightforward method to incorporate chat capabilities without managing the underlying infrastructure. Moreover, Telegram's API provides extensive features, including media handling, inline queries, and more.

Creating Interactive Chat UI with IPyWidgets

Enhancing user interaction within Jupyter notebooks can be achieved using interactive widgets provided by the ipywidgets library. These widgets allow the creation of custom user interfaces for chat applications.

Setting Up IPyWidgets

First, ensure that ipywidgets is installed:

pip install ipywidgets

Implementing a Chat Interface

Insert the following code into a new notebook cell to create an interactive chat interface:

from ipywidgets import widgets from IPython.display import display import asyncio import websockets import threading async def chat_interface(message_widget, output_widget, websocket): async def send_message(change): message = message_widget.value if message: await websocket.send(f"User: {message}") message_widget.value = '' message_widget.on_submit(send_message) try: async for message in websocket: output_widget.value += f"{message}\n" except websockets.ConnectionClosed: output_widget.value += "Disconnected from chat server." async def start_chat_ui(room, output_widget): uri = "ws://localhost:12345" async with websockets.connect(uri) as websocket: await websocket.send(room) await chat_interface(widgets.Text(), output_widget, websocket) def launch_chat_ui(): room = input("Enter room name to join: ") output = widgets.Textarea( value='', placeholder='Chat messages will appear here...', description='Chat:', disabled=True, layout={'width': '100%', 'height': '300px'} ) display(output) asyncio.run(start_chat_ui(room, output)) # Run the chat UI in a separate thread to avoid blocking ui_thread = threading.Thread(target=launch_chat_ui) ui_thread.start()

Executing this cell prompts for a room name and displays a text area where chat messages appear. An input box allows users to send messages to the selected room. This setup leverages ipywidgets to provide a responsive and interactive chat interface within the notebook.

Enhancing Functionality

While basic chat communication allows for sending and receiving messages, enhancing the system with additional features can significantly improve usability and scalability.

Multiple Chat Rooms

Supporting multiple chat rooms enables users to organize conversations based on topics or projects. The server-side implementation already accommodates multiple rooms by maintaining a dictionary of connected clients per room. Ensure that clients specify the room they wish to join upon connection.

User Authentication

Implementing user authentication ensures that only authorized users can access specific chat rooms. This can be achieved by integrating authentication mechanisms, such as token-based authentication or utilizing existing services like OAuth.

Private Messaging

Allowing private messages between users enhances privacy and communication efficiency. This requires modifications to the server to handle direct message routing based on user identities.

Message History

Storing and retrieving past messages provides context for ongoing conversations. Implement a message history feature by maintaining a database or in-memory storage that logs all messages exchanged within a chat room.

Security and Encryption

Securing chat communication is paramount, especially when transmitting sensitive information. Implement encryption protocols like SSL/TLS to protect data integrity and privacy. Additionally, employ best practices for secure coding to mitigate vulnerabilities.

Best Practices and Troubleshooting

Developing a robust chat system involves adhering to best practices and proactively addressing potential issues.

Common Issues

Port Already in Use: Ensure the chosen port (e.g., 12345 or 55555) is not occupied by other applications. Change the port number if necessary.
Connection Refused: Verify that the server is running and listening on the specified port. Check firewall settings to allow connections.
Message Delivery Failures: Ensure clients are connected to the correct chat room. Inspect server logs for runtime errors.

Best Practices

Exception Handling: Implement comprehensive error handling to manage unexpected disconnections and runtime errors gracefully.
Input Validation: Validate all user inputs to prevent injection attacks and ensure data integrity.
Logging: Maintain detailed logs of server and client activities to facilitate debugging and monitoring.
Security Measures: Encrypt data transmissions and implement authentication to safeguard user information.
Modular Code Structure: Organize code into reusable modules to enhance maintainability and scalability.

Conclusion

Implementing chat communication outside the browser using Python notebooks opens up a myriad of possibilities for collaborative and interactive projects. By leveraging technologies like WebSockets, socket programming, messaging APIs, and interactive widgets, developers can create robust and scalable chat systems tailored to their specific needs. Whether integrating advanced features like user authentication and message history or utilizing existing platforms like Telegram for streamlined communication, Python offers the flexibility to build efficient chat solutions within the Jupyter ecosystem. Adhering to best practices ensures that these systems are secure, maintainable, and capable of handling real-world demands.