Skip to main content
100%

Gist ef01d3ebfb3e6f5704bd

✓ Published0🌍 Public
Aahmohamed
Last edited Jul 19, 2012
Created on Apr 9, 2015

This example demonstrates a minimal WebSocket server implemented in Python, showing how to establish a handshake and exchange framed messages. It uses `SocketServer.StreamRequestHandler` for the network layer, manually performs the WebSocket handshake via `sha1` and `b64encode` against the defined magic string, and parses incoming frames by XOR-masking payload bytes. The code handles payload lengths up to 64-bit values and sends text frames with a 129 opcode. It prints received messages to the console, illustrating the core protocol mechanics without any visualization or data rendering.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 48d689f1ba856686fff5

This example demonstrates a simple WebSocket-based message exchange between a server and a browser client. The server sends a `server_ping` event with a `Hello bob` payload, and the client’s JavaScript listens for that event, logs the incoming message to the console, and also handles disconnections. The visualization itself is minimal, relying on the browser console for output rather than graphical rendering. The code uses the raw WebSocket API through a channel object (likely from a library like Socket.IO or similar) and standard `console.log` for feedback.

Aandybak
71% match
Loading thumbnail…

Gist 89f2cb981924f2b2ad1b68db99a087af

This example demonstrates a secure HTTP POST request that sends a small JSON payload containing a message, an ID, and a timestamp to a local server endpoint. The Python script builds the request using the `requests` library, formats the data with `json.dumps` (using compact separators and sorted keys), and includes custom authentication headers (`x-pk` and `x-pass`). The server responds with an encrypted string, which the script prints alongside the original data and formatted payload for verification.

CCarlos-Augusto
61% match
Loading thumbnail…

Gist 34e6ce90cbeecb0bce1d89474d770d28

This example demonstrates a minimal HTTPS setup for PeerJS, showing how to serve a WebRTC signaling page alongside a peer server on the same Express application. The code uses the `express` framework, `https.createServer` with Let’s Encrypt certificates, and `ExpressPeerServer` to handle peer connections at `/peerjs/myapp`. A static HTML page loaded from the root path initializes a `Peer` with a fixed ID, connecting to the specified domain and port. The example relies on the `peerjs` client library and Node.js `fs` to read the SSL credentials, illustrating a secure deployment pattern for WebRTC applications.

UUtopiah
59% match
Loading thumbnail…

Gist 1070395

This example demonstrates a real-time messaging dashboard where a Node.js server relays messages to a browser client over the Faye Bayeux protocol. It shows how server-side JavaScript publishes messages to a subscribed client, which logs incoming text to the console. The code sets up an HTTP server with `http.createServer`, serves static HTML files from the filesystem, and attaches Faye’s `NodeAdapter` to handle WebSocket connections at `/faye`. A `Faye.Client` subscribes to the `/messages` channel, receiving and printing each message’s `text` property. The rendering relies on terminal output rather than visual charts.

Aalessioalex
59% match
Loading thumbnail…

Flaschen Taschen in Python Workshop

This example demonstrates how to create a pixel-based animation display for the Flaschen Taschen LED panel using Python sockets. The code shows a simple animation that sends raw pixel data to a terminal-based server, with the rendering approach explained through the ft-server setup for Linux and macOS. The workshop covers the socket communication between client and server, as well as the Python data manipulation techniques used to format the image data for transmission. It also discusses composition versus inheritance in the context of structuring animation code, using the Python standard library’s socket module for network communication.

TTheLady
58% match
Loading thumbnail…

Gist 75fe6f98cacb874f8d9ebce7248b1b66

This example presents a web-based client-server application that serves static files and handles socket connections. The server is built with Express and Socket.IO, listening on a configurable port, and delegates all routes to a single `index.html` file. It uses the `body-parser` middleware for JSON parsing and the `path` module to resolve file locations. The rendering approach is not specified, but the code clearly establishes the infrastructure for delivering a front-end visualization, with the server acting as the backbone for real-time communication and static asset delivery.

RRonolibert
57% match
Loading thumbnail…

The code in this gist isn't as succinct as I'd like it to be. Please bare with me and ask plenty of questions that you may have about it.

This example implements a minimal blockchain visualization server using Flask, exposing endpoints to submit transactions, retrieve the current chain, and mine new blocks. The code defines a Block class with SHA-256 hashing and a proof-of-work algorithm that increments values until divisible by 9 and the previous proof. It includes consensus logic to compare chain lengths across peer nodes via HTTP GET requests. The visualization aspect is limited to JSON responses of block data, with no graphical rendering or front-end library in use.

SSassOnTheRoad
56% match
Loading thumbnail…

node-websocketd

This example demonstrates a lightweight Node.js port of the websocketd tool, which exposes a command-line script over a WebSocket connection. It shows how a spawned child process can receive input from and send output to a connected browser client in real time. The implementation uses the `ws` Server to handle WebSocket connections, `websocket-stream` to create a duplex stream over the socket, and `child_process.spawn` to execute the user-supplied command. Standard input and output are piped between the stream and the spawned process, with the process being killed when the stream ends.

Aalessioalex
55% match