Socket interfaces facilitate network communication between hosts over IP networks. In Python, the socket module provides access to BSD-style sockets. This implementation focuses on TCP-based endpoints using custom wrapper classes for cleaner state management.

Server-Side Architecture

A standard TCP server initializes an IPv4 socket, binds it to a specific address, and enters a listening state. Custom subclasses can encapsulate configuration parameters.

import socket

class TCPServer(socket.socket):
    """Encapsulates server configuration and lifecycle"""

    def __init__(self, host, port):
        super().__init__(socket.AF_INET, socket.SOCK_STREAM)
        
        # Enable address reuse to prevent binding errors
        self.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        
        self.host = host
        self.port = port
        self.bind((self.host, self.port))
        self.listen(1280)

    def handle_client(self, client_socket, address):
        """Process incoming connection requests"""
        try:
            raw_data = client_socket.recv(1024).decode('utf-8')
            print(f"[{address}] Received: {raw_data}")
            
            response = "Message received successfully"
            client_socket.send(response.encode('utf-8'))
        except Exception as e:
            print(f"Error handling client: {e}")
        finally:
            client_socket.close()

To manage active sessions, iterate over accepted sockets continuously.

def run_server(server_instance):
    while True:
        conn, addr = server_instance.accept()
        server_instance.handle_client(conn, addr)

Client-Side Implementation

Clients require fewer states but benefit from consitsent encoding handling within their interface.

class TCPClient(socket.socket):
    """Manages outbound connections and data transmission"""

    def __init__(self, host, port):
        super().__init__(socket.AF_INET, socket.SOCK_STREAM)
        self.connect((host, port))

    def send_message(self, message):
        """Encode string payload and transmit via network"""
        return self.send(message.encode('utf-8'))

    def receive_message(self, buffer_size=1024):
        """Decode incoming byte stream into a readable string"""
        data = self.recv(buffer_size)
        return data.decode('utf-8') if data else None
    
    def cleanup(self):
        """Terminate the session"""
        self.close()

Execution Flow

Instantiating the client establishes the handshake immediately up on construction.

if __name__ == "__main__":
    HOST = "127.0.0.1"
    PORT = 8080
    
    client_handler = TCPClient(HOST, PORT)
    
    try:
        request_payload = "Hello, Socket Service"
        client_handler.send_message(request_payload)
        print(f"Server Reply: {client_handler.receive_message()}")
    finally:
        client_handler.cleanup()