Python notes

Pruna is a model optimization framework built for developers, enabling you to deliver faster, more efficient models with minimal overhead.

https://github.com/PrunaAI/pruna

Dave Jones delivers a playbook for packaging and distributing Python scripts as single-file applications leveraging uv and PEP 723. It covers installing uv, embedding package dependencies, and configuring scripts for system-wide invocation via shebangs and virtual environments.

https://thisdavej.com/share-python-scripts-like-a-pro-uv-and-pep-723-for-easy-deployment/

Egglog introduces a lightweight declarative schema that unifies experimental run provenance and log management. This overview highlights how VectorFold’s new tool structures metrics, metadata, and artifacts in reproducible JSON logs for seamless analysis and sharing.

https://vectorfold.studio/blog/egglog

ArjanCodes reveals how to craft high-performance Docker images for Python applications using his 3-Factor Framework. This demonstration covers choosing lean base images, multi-stage builds, secret mounting, and non-root execution to accelerate builds and tighten security.

https://www.youtube.com/watch?v=tc713anE3UY

Fully local web research and report writing assistant

https://github.com/langchain-ai/local-deep-researcher

Claudio Santini’s primer on Unvibe reveals a Python library that treats unit-tests as a reward function, guiding LLM-driven Monte Carlo Tree Search to generate code that passes all tests. It details how Unvibe decorates functions with @ai, uses unvibe.TestCase for granular scoring, and iteratively refines implementations by feeding back assertion errors to the model.

https://claudio.uk/posts/unvibe-a-python-test-runner-that-generates-correct-implementations.html

Akshay Kagrawal, Myles, and Dylan Madisetti’s “Python, not JSON: a new plaintext file format” rethinks Jupyter notebooks as importable, reusable Python modules instead of monolithic JSON blobs. This walkthrough shows how marimo files deliver Git-friendly diffs, module imports, pytest compatibility, and embedded SQL and Markdown for a maintainable interactive computing experience.

https://marimo.io/blog/python-not-json

Engineer’s Codex’s “The Boolean Trap” warns developers against using boolean flags in APIs and shows how they can hinder code readability and extensibility. This analysis advocates for using enums to represent function parameters, demonstrating how they improve clarity, maintainability, and future-proofing in real-world software design.

https://read.engineerscodex.com/p/the-boolean-trap

A collaborative note taking, wiki and documentation platform that scales. Built with Django and React. Opensource alternative to Notion or Outline.

https://github.com/suitenumerique/docs

Julia Evans’s “Terminal Rules” catalogs seven de facto conventions that make terminal programs behave predictably, from signal handling to color and input handling. This breakdown walks through rules such as using Ctrl-C to quit noninteractive programs, Ctrl-D to exit REPLs, and disabling colors when piping output.

https://jvns.ca/blog/2024/11/26/terminal-rules/

In “Binary Search as a Bidirectional Generator,” the author proposes treating the classic binary search as a bidirectional Python generator. This exposition shows how Python’s send method enables ergonomic, decoupled control flow for efficient search routines.

https://mathspp.com/blog/binary-search-as-a-bidirectional-generator

Nelhage’s exploration of CPython’s new tail-call interpreter uncovers how an LLVM regression inflated early benchmark gains. This article details computed-goto mechanics, the LLVM 19 regression, and broader lessons in performance engineering.

https://blog.nelhage.com/post/cpython-tail-call/

Simple gitlab backup. Backup all your repositories.

https://github.com/tutunak/sb-gitlab

This DataCamp blogpost demonstrates how to use Python for analyzing and predicting Bitcoin price patterns through time series analysis, focusing on both long-term and short-term trends. The article guides readers step-by-step through data collection, preprocessing, decomposition (additive and multiplicative), and the application of technical indicators like moving averages and RSI to uncover seasonal cycles, micro-patterns, and actionable trading signals in Bitcoin’s volatile price history.

https://www.datacamp.com/blog/python-bitcoin

MicroPie is an ultra-micro ASGI Python web framework that gets out of your way.

https://github.com/patx/micropie

David Guillot’s experiment investigates how web push notifications, when combined with Progressive Web Apps (PWAs), can offer a compelling alternative to traditional mobile apps for user engagement. By leveraging Django and packages like django-webpush and django-pwa, the article demonstrates a practical approach to implementing reliable, native-feeling notifications on both desktop and mobile-highlighting UX design considerations, technical constraints (such as iOS requiring PWA installation for notifications), and offering a live demo to gather community feedback on usability and device impact.

https://david.guillot.me/en/posts/tech/web-push-notifications-an-experiment/

OpenTelemetry is an open source, vendor-neutral observability framework that provides standardized APIs, libraries, and tools to collect telemetry data-such as metrics, logs, and traces-from your application, allowing you to monitor different systems and platforms seamlessly and future-proof your monitoring setup. To add OpenTelemetry to a Django application, you can use either automatic or manual instrumentation: automatic instrumentation involves installing packages like opentelemetry-instrumentation-django and configuring environment variables and your Django settings to export data to an observability backend (such as Elastic), while manual instrumentation gives you finer control by adding tracing and metrics code directly to your views and models, enabling custom monitoring of application behavior and performance.

https://allthingsopen.org/articles/what-is-opentelemetry-add-django-application

Installing Python dependencies with pip can be frustratingly slow, especially in CI pipelines or when building Docker images. This guide discusses how to speed up the process by focusing on using pre-built wheels instead of source distributions, leveraging package caching, disabling bytecode compilation when appropriate, and considering faster alternatives like uv, a Rust-based package installer that parallelizes downloads and skips bytecode compilation by default.

https://pythonspeed.com/articles/faster-pip-installs

A Self-adaptation Framework🐙 that adapts LLMs for unseen tasks in real-time!

https://github.com/SakanaAI/self-adaptive-llms

Phil Eaton’s recent blogpost explores how to embed Python within Rust for the purpose of running tests, offering a hands-on guide to setting up a Rust-based test runner that can execute Python scripts and even expose Rust functions to Python code. This practical walkthrough highlights the flexibility of combining Rust’s performance with Python’s scripting capabilities for more dynamic and parallel test scenarios.

https://www.enterprisedb.com/blog/embedding-python-rust-tests