Start free Log in

A

adewes

@adewes·20 public vizzes

Loading thumbnail…

Temperature Tracking Script

This script tracks the temperature of an aquarium using a DS18B20 sensor, logging the value every minute to a tab-separated file with a timestamp. It visually demonstrates the data over time by appending lines like `date<TAB>temperature` to `temperature.tsv`. The code reads raw sensor values from the Linux sysfs interface at `/sys/bus/w1/devices/.../temp1_input`, checking for missing or out-of-bounds readings, and prints alerts or a daily summary message. It uses shell commands (`date`, `cat`, `echo`) rather than a visualization library, relying on the file’s tabular format for later charting.

Loading thumbnail…

Borg Backup Script

This example visualizes the backup decision logic of a Borg backup helper script, showing the time elapsed since the last backup and whether a new backup is due. It calculates the interval using shell commands and date arithmetic, comparing hours elapsed against a 24-hour threshold. The script uses the `stat` command to read the modification timestamp from `last_backup.txt`, `expr` for arithmetic, and the Borg CLI with `borg create` to perform the backup, including exclusions for patterns like `**/node_modules`. The visualization relies on the script’s output, echoing days and hours since the last backup.

Loading thumbnail…

Contracts in Python

This example demonstrates runtime type checking for Python function arguments and return values using function annotations and custom validator classes. The code defines a `Validated` metaclass and validator classes like `TypeChecked`, `Range`, and `Positive`, which are combined through the `checked` decorator to enforce constraints such as type and value ranges on parameters like `x`, `y`, and `z`. It uses the `inspect` module to parse function signatures and annotations, and the `functools` module for wrapping. The sample function `f` shows valid and invalid calls, raising `TypeError` for type mismatches and `ValueError` for out-of-range values.

Loading thumbnail…

The build watcher: Automatically rebuild Pelican content as files change.

This example shows a Makefile-based watch loop that automatically rebuilds Pelican content whenever files in the project directory change. It uses the inotifywait command-line tool to monitor the directory recursively for create, delete, move, and modify events, triggering the `make html` target on each detected change. The loop runs indefinitely, breaking only if inotifywait fails or the build command errors. The code explicitly checks for inotifywait’s presence at startup, requiring the user to install it if missing, and documents the watcher’s role with a Game-of-Thrones–inspired comment block.

Loading thumbnail…

Finding circular dependencies in your SQLAlchemy data scheme

This visualization identifies circular dependencies in SQLAlchemy database schemas by traversing foreign-key relationships between tables. It uses the `metadata.sorted_tables` object to extract table names and their referenced tables via `foreign_key_constraints`, building a dependency graph as a `defaultdict` of sets. A recursive graph-walking function then detects cycles, printing each circular path as a string of table names joined by arrows. The example relies on Python’s standard library and SQLAlchemy’s metadata API, with no external visualization library; output is textual, showing dependency chains directly in the console.

Loading thumbnail…

Ebay Ads - Bot. Because who wants to write messages by hand...

A Python bot monitors a Berlin apartment-search query on eBay Kleinanzeigen, filtering new listings by criteria like rent, room count, and district. It notifies the user via Slack and automatically sends a predefined contact message to promising ads. Built with Selenium for browser automation and the requests library for Slack webhook delivery, it stores visited ads in a JSON file to avoid duplicate outreach.

Loading thumbnail…

Eight Queens Problem Solved using Common Table Expressions

A SQL query using recursive Common Table Expressions solves the Eight Queens puzzle, enumerating all 92 valid board configurations. The recursive `solutions` CTE incrementally places queens, checking row, column, and diagonal conflicts via arithmetic on board positions. A separate `positions` CTE generates the 64 board cells. A Python script executes the SQL against an in-memory SQLite database, iterating over the result rows and printing each 8×8 board as a text grid with asterisks marking queen placements.

Loading thumbnail…

keybase.md

This example visualizes a cryptographic identity proof, showing how a GitHub account (adewes) is cryptographically linked to a Keybase identity (dewes) via a PGP-signed JSON object. The gist file contains the signed statement and its raw JSON payload, including the public key fingerprint and service bindings. It does not use a visualization library; instead, it relies on the textual and structured data from the Keybase proof system, with the JSON object and PGP signature displayed directly as the primary content. The rendering approach is plain text formatting, preserving the original gist structure.

Loading thumbnail…

A Redis-based distributed lock class, based on the solution proposed by Chris Lamb (https://chris-lamb.co.uk/posts/distributing-locking-python-and-redis).

This example demonstrates a distributed lock implementation for coordinating access to shared resources in a Python application. It shows a `Lock` class that uses Redis’s watch-multi-exec transaction pipeline to atomically acquire and release locks, with expiration and retry logic to handle contention. The code uses `redis.Redis`, `pipeline()`, `watch()`, `execute()`, and `delete()`, along with `time.sleep` and `time.time` for timeout handling. A command-line test acquires a lock on key `user:abc` for 10 seconds, then releases it after a simulated 20-second wait.

Loading thumbnail…

Python: Dictionary Value Exporter

This example demonstrates a utility for selectively exporting values from nested Python dictionaries, returning only the specified keys while omitting others such as passwords. The function recursively traverses the dictionary structure, supporting tuples, lists, wildcards (`*`), and nested dictionaries as key specifications. The code uses only Python’s built-in types and functions—`isinstance`, `dict.items`, and recursion—with no external libraries. The sample data contains server IPs and credentials, and the export call extracts the name and IP addresses while dropping passwords, producing a cleaned, filtered dictionary as output.

Loading thumbnail…

The Hacker School Effect

The visualization tracks the author’s computer usage over time, comparing activity before and during their Hacker School batch. It reveals a clear shift toward coding-focused applications and increased keyboard input during the program. The notebook loads JSON time-tracking data from a Python script, then aggregates per-timestamp records of active windows, key presses, and mouse movement. Using Python’s `json` module and `defaultdict`, it processes the raw logs to compute daily summaries, which are plotted to show the “Hacker School Effect” as a rise in terminal and editor usage alongside a dip in browser time.

Loading thumbnail…

Acht Königinnen

This visualization solves the eight queens puzzle by generating all 64 single-queen board states, encoding each as a string of characters, and computing pairwise compatibility between states. It then recursively narrows down combinations of queens that do not attack each other, printing each valid solution as a grid of "Q" (queen), "O" (free), and "X" (attacked) cells. The code uses Python’s `reduce` for flattening state lists and standard list comprehensions to filter compatible states, with no external visualization libraries. The final output lists all 92 solutions, counting them via a simple loop.

Loading thumbnail…

A map-reduce class in Python, with the typical "hello, world!" word-counting example. You can download ulysses.txt file used in the example here: http://www.gutenberg.org/ebooks/4300

This example demonstrates a word-frequency analysis of James Joyce’s *Ulysses*, showing the 100 most common words and their counts. It uses a custom `MapReducer` class, built with Python’s `abc` module for abstract methods, to implement the map-reduce pattern. The `WordReducer` subclass defines a `map` method that tokenizes lines and tallies lowercase word occurrences, while `reduce` sums the counts. The `mapreduce` method groups mapped key-value pairs via `collections.defaultdict`. The final sorted output is printed with `pprint` from the text file downloaded from Project Gutenberg.

Loading thumbnail…

Get the active window in Gtk using the wnck library.

This example demonstrates a simple text-based monitoring loop that continuously prints the name of the active window on a Gtk desktop. It shows the current window title every half second, updating as the user switches between applications. The code uses the wnck library’s `screen_get_default()` and `get_active_window()` APIs to query window information, while Gtk’s `events_pending()` and `main_iteration()` keep the GUI event loop responsive. The output is a raw console stream of window names, with no visual rendering or data aggregation.

Loading thumbnail…

A Flask decorator that takes a response with JSON content and converts it to a well-formatted JSONP response.

This example shows a Flask decorator that transforms a standard JSON response into a JSONP response by wrapping the payload in a callback function. The decorator checks for a `callback` parameter in the request arguments and aborts with a 404 if it is missing. It then calls the wrapped view function, converts the result to a response object if it is a plain string, and replaces the response data with `callback(payload)` while setting the MIME type to `application/javascript`. The code uses Flask’s `request.args`, `make_response`, and `abort` APIs, along with `functools.wraps` to preserve function metadata.

Loading thumbnail…

Sometimes you just need an SQL table filled with some natural numbers. Here's a simple & brute-force solution that will work on ANY SQL dialect. It returns a table with an arbitrary number of natural numbers, provided this number is equal to 10.000... I used this on ExaSOL, where most Oracle / MSSQL magic does not work.

This example shows a SQL table named `natural_numbers` containing a single column `n` with integer values. The brute-force solution generates a sequence of natural numbers from 1 to 10000 by explicitly listing every value in a single `INSERT INTO` statement, making it compatible with any SQL dialect, including Exasol, where common alternatives like Oracle's `CONNECT BY` or MSSQL's `WITH` recursion may not work. The table is created with a simple `CREATE TABLE` statement followed by an exhaustive `VALUES` list, providing a straightforward, if verbose, method for generating a range of natural numbers without relying on dialect-specific features. The visualization highlights the impracticality of this approach for large ranges, while demonstrating a universal fallback technique.**Title:** Brute-Force Natural Numbers Table for Any SQL Dialect **Description:** This example demonstrates a remarkably simple, albeit verbose, SQL approach to generating a table of natural numbers from 1 to 10,000. Instead of relying on dialect-specific functions or recursive CTEs—which often fail on platforms like ExaSOL—the author manually constructs the table using a single `INSERT` statement with 10,000 explicit value tuples. The result is a portable, dependency-free way to create a numbers table, though it requires copying a very long list of values. A humorous take on a common developer need, this gist highlights the trade-off between universal compatibility and brute-force practicality. **Files:** - `natural_numbers.sql` — contains the full `CREATE TABLE` and `INSERT` statements to generate the sequence.This example from adewes showcases a delightfully pragmatic SQL workaround: generating a sequence of natural numbers in ExaSOL, where common recursive or procedural methods aren't available. The `natural_numbers.sql` file uses a purely brute-force approach, explicitly inserting values from 1 to 10,000 with a single `INSERT` statement. While verbose, this solution is guaranteed to run on virtually any SQL dialect, making it a useful fallback when more elegant methods fail. The visualization gallery entry would emphasize this as a humorous yet functional illustration of SQL portability constraints and creative problem-solving—a "sometimes you just need" workaround that trades elegance for universal compatibility.

Loading thumbnail…

Simple functions to calculate expected number of failures and workload in systems that can process a given number of subscribers in parallel, using a binomial distribution model to simulate subscriber behavior. Applicable e.g. to web servers & cellphone base stations.

This example demonstrates how to estimate the expected workload and number of processing failures for a system with limited parallel capacity, such as a web server or cellphone base station. The code uses `scipy.stats.binom` to calculate the binomial probability mass function for each possible number of concurrent subscribers, then sums weighted contributions to derive the two metrics. The `workload` function computes the average percentage of capacity utilized, while `failures` sums the excess subscribers beyond the capacity limit. Both functions iterate over subscriber counts, applying the binomial distribution to model subscriber behavior at a given call probability.

Loading thumbnail…

Scripts for getting the full list of Github users (get_all_github_users.py) and for retrieving the details of these users (get_github_user_details.py) using the Github API.

Two Python scripts demonstrate how to query the GitHub API for a complete list of all user accounts. The first script, `get_all_github_users.py`, paginates through `https://api.github.com/users` using the `requests` library, handling rate limits and writing each user ID to a JSON file. The second, `get_github_user_details.py`, uses `multiprocessing` with a pool of five processes to fetch detailed profile information for each user via HTTPS connections to `api.github.com`, saving the results incrementally. Together they show batch data harvesting from a REST API with concurrency and rate-limit awareness.

Loading thumbnail…

A small Python script to generate random color sequences, e.g. for use in plotting. Just call the "generate_new_color(existing_colors,pastel_factor)" function to generate a random color that is (statistically) maximally different from all colors in "existing_colors". The "pastel_factor" parameter can be used to specify the "pasteliness"(?) of the produced colors (please, don't you chose 0...)

This example demonstrates a Python utility for generating a sequence of visually distinct random colors, suitable for plotting or data visualization. It shows how to produce colors that are maximally different from a set of existing colors, with a `pastel_factor` parameter controlling pastel softness. The script uses Python’s `random` module to sample candidate RGB values and computes a simple Manhattan-distance metric (`color_distance`) to select the best candidate. The main function, `generate_new_color`, iterates 100 times to find the color with the greatest minimum distance from all previously chosen colors, with the example loop generating ten colors.

Loading thumbnail…

Hierarchical Pie Chart

This hierarchical pie chart visualizes the file and directory structure of a Flask project. Each ring level represents a directory depth, and the angular extent of each slice is proportional to the number of lines and bytes in that file or folder. Clicking a slice triggers an animated rebasing that zooms into the selected hierarchy level, recalculating angles and radii to make that slice the new root. Hovering reveals a legend with details, and the SVG uses smooth transitions to adjust arcs, illustrating the nested codebase composition.