Python selectors Module: Advanced Usage and Installation Guide

import socket  # Import the socket library to create a socket
import selectors  # Import the selectors module to manage I/O operations

# Create a socket and bind it to localhost on port 8080
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('localhost', 8080))
server_socket.listen()  # Set the socket to listening state
server_socket.setblocking(False)  # Make the socket non-blocking

# Create a default selector
selector = selectors.DefaultSelector()
# Register the server socket to listen for incoming connections
selector.register(server_socket, selectors.EVENT_READ)

print("Server is listening on port 8080...")

while True:
    # Wait for an event to occur
    events = selector.select()  
    for key, _ in events:  # Iterate over triggered events
        if key.fileobj is server_socket:  # Check if the event is from the server socket
            client_socket, addr = server_socket.accept()  # Accept the connection
            print(f"Accepted connection from {addr}")
            client_socket.setblocking(False)  # Make the client socket non-blocking
            # Register the client socket to listen for data receipt
            selector.register(client_socket, selectors.EVENT_READ)
        else:
            data = key.fileobj.recv(1024)  # Read data from the socket
            if data:
                print(f"Received data: {data}")  # Print the received data
            else:
                # Unregister the socket if no data is received (client disconnects)
                selector.unregister(key.fileobj)  
                key.fileobj.close()  # Close the client socket

import socket
import selectors
import types  # Import types for creating custom data types

selector = selectors.DefaultSelector()  # Create a default selector

def create_socket(host, port):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind((host, port))
    sock.listen()
    sock.setblocking(False)  # Set to non-blocking
    selector.register(sock, selectors.EVENT_READ, data=None)  # Register socket
    return sock

def accept_connection(sock):
    conn, addr = sock.accept()  # Accept incoming connections
    print(f"Connection accepted from {addr}")
    conn.setblocking(False)  # Set connection to non-blocking
    selector.register(conn, selectors.EVENT_READ, data=types.SimpleNamespace(addr=addr))  # Register the connection

def service_connection(key, mask):
    sock = key.fileobj
    data = sock.recv(1024)  # Attempt to receive data
    if data:
        print(f"Data received from {key.data.addr}: {data}")  # Print data
    else:
        print(f"Closing connection to {key.data.addr}")  # Connection closed
        selector.unregister(sock)  # Unregister socket
        sock.close()  # Close socket

# Create a server socket
server_sock = create_socket('localhost', 9090)
print("Server running on port 9090...")

while True:
    for key, mask in selector.select():  # Process events
        if key.data is None:
            accept_connection(key.fileobj)  # Accept new connections
        else:
            service_connection(key, mask)  # Handle existing connections

import socket
import selectors

selector = selectors.DefaultSelector()  # Create a selector object

def start_server():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # Create a TCP socket
    server.bind(('localhost', 8081))  # Bind the server to localhost and port 8081
    server.listen()  # Start listening for connections
    server.setblocking(False)  # Make the socket non-blocking
    selector.register(server, selectors.EVENT_READ)  # Register for I/O events
    print("Echo server started on port 8081...")

def handle_client(client_socket):
    data = client_socket.recv(1024)  # Receive data from the client
    if data:
        print(f"Echoing back: {data}")  # Print the data received
        client_socket.send(data)  # Send the data back to the client
    else:
        selector.unregister(client_socket)  # Unregister client socket
        client_socket.close()  # Close the connection

start_server()  # Start the echo server

try:
    while True:
        events = selector.select()  # Wait for events
        for key, _ in events:
            if key.fileobj is server:  # Incoming connection
                client_socket, addr = server.accept()  # Accept the connection
                print(f"Connection from {addr}")
                client_socket.setblocking(False)  # Set it to non-blocking
                selector.register(client_socket, selectors.EVENT_READ)  # Register for events
            else:
                handle_client(key.fileobj)  # Handle existing client connections
except KeyboardInterrupt:
    print("Server stopping...")
finally:
    selector.close()  # Close the selector