Chapter 1: Introduction to Real-Time Applications

Developing scalable real-time data streaming solutions can be a complex endeavor. Particularly, applications that facilitate connections between client and server can automatically notify clients without requiring them to constantly check in with the server.

This article will illustrate how to create interactive real-time applications using WebSockets in Python.

For instance, when visiting the Yahoo Finance webpage, users can observe that stock prices refresh automatically without any manual page reload. Similarly, chatbot servers can send notifications to clients without a refresh, and trading or gaming applications can push updates to clients as data becomes available. Many organizations utilize JavaScript for client applications while employing Python for server-side programming.

This guide will explore how to harness WebSockets in Python for real-time streaming applications.

We leverage WebSockets to develop interactive data streaming applications. A widely accepted method for creating fast real-time applications is through the WebSockets communication protocol. Below, I provide a working example that illustrates how WebSockets function in practice.

Chapter 2: Implementing a WebSocket Application

To get started, you will need to install the following dependencies:

pip install websockets

I prefer using the websockets library for its simplicity and robustness, as it is built on asyncio, providing an elegant coroutine-based API.

Creating a WebSocket Server

Begin by creating a file named websocket_server.py and insert the following code:

import asyncio

import datetime

import time

import websockets

class WebSocketServer:

def __init__(self, host, port, secret):

self._secret = secret

self._server = websockets.serve(self._start, host, port)

def start(self):

asyncio.get_event_loop().run_until_complete(self._server)

asyncio.get_event_loop().run_forever()

async def _start(self, websocket, path):

print(f"Connected from path ={path}")

while True:

secret = await websocket.recv()

if secret == self._secret:

time.sleep(1)

msg = f"Sending message {datetime.datetime.now()}"

await websocket.send(msg)

print(msg)

if __name__ == "__main__":

server = WebSocketServer("127.0.0.1", 6969, "fintechexplained")

server.start()

This code sets up a WebSocketServer class that wraps around the websockets library. It listens for incoming client connections and, upon receiving a specific message, responds with a timestamped message.

Creating a WebSocket Client

Next, create a file called websocket_client.py and add the following code:

import asyncio

import websockets

class WebSocketClient:

def __init__(self, host, port, secret):

self._secret = secret

self._host = host

self._port = port

def start(self):

asyncio.get_event_loop().run_until_complete(self._start_receiving())

async def _start_receiving(self):

url = f'ws://{self._host}:{self._port}/websocket-blog'

try:

async with websockets.connect(url) as websocket:

await websocket.send(self._secret)

while True:

await websocket.send(self._secret)

response = await websocket.recv()

print(f'Received Message: {response}')

except websockets.ConnectionClosed as ex:

print(ex)

raise

if __name__ == "__main__":

client = WebSocketClient("127.0.0.1", 6969, "fintechexplained")

client.start()

This WebSocketClient class connects to the server and continuously sends and receives messages.

Running the WebSocket Server and Client

1. Execute websocket_server.py in one terminal.
2. Execute websocket_client.py in another terminal.

Once the client connects and sends its initial message, the server will start sending messages in response.

Summary of WebSocket Architecture

Utilizing multiple WebSocket servers and clients within isolated containers can enhance efficiency. Containers provide numerous benefits, such as faster application deployment, scalability, and improved management.

For further insights into containers and their advantages, I recommend exploring additional resources.

Chapter 3: Video Resources

To enhance your understanding of building real-time applications, consider watching the following videos:

This video, titled "Build Streaming Data Applications in Minutes Using SwimOS and Nstream," provides an overview of rapid application development in streaming data.

In this video, "Build On AWS - Building a Live Streaming App in 25 Minutes," you will learn to create a live streaming application using AWS tools.

This article has demonstrated how to develop real-time interactive applications using WebSockets in Python.