Python Bytes

Topics covered in this episode:

Pandas Should Go Extinct

Pydantic-pint puts real-world units in your Pydantic models

How Libraries Run Rust Inside Python (With PyO3)

AWS acquires DuckLabs

Extras

Joke

Watch on YouTube

Sponsored by Logfire from Pydantic: pythonbytes.fm/logfire

Connect with the hosts

Michael: Mastodon / BlueSky / X / LinkedIn

Calvin: Mastodon / BlueSky / X / LinkedIn

Show: Mastodon / BlueSky / X

Join us on YouTube at pythonbytes.fm/live to be part of the audience. Usually Tuesday at 7am PT. Older video versions available there too.

Finally, if you want an artisanal digest of every week of the show notes in email form? Add your name and email to our friends of the show list, we'll never share it.

Calvin #1: Pandas Should Go Extinct

Pandas' slowness pushes teams toward "Big Data" tools (Spark, Databricks) they don't actually need — most workloads never hit true Big Data scale

Amazon Redshift telemetry: ~95% of tables are under 100GB, ~87% of queries touch 80GB or less — that's "Medium Data," not Big Data

Polars and DuckDB fill that gap: single-machine, fast, no cluster required

1 Billion Row Challenge benchmark: Pandas took 4m28s vs. Polars 5.04s and DuckDB 5.19s — DuckDB also used 19x less memory

On a real-world NYC taxi dataset (3GB parquet), pure DuckDB ran 2x faster than pure Pandas while using a fraction of the RAM

Bonus: Apache Arrow lets you pass data between Pandas/Polars/DuckDB with zero copying, so trying them out doesn't mean a full rewrite

Michael #2: Pydantic-pint puts real-world units in your Pydantic models

Pydantic-pint bridges Pydantic and Pint so models can validate physical quantities like 4m or 12 meters instead of bare floats. Fields annotated with PydanticPintQuantity parse user input, convert between compatible units, and serialize quantities back out as strings. That closes a real gap for anything consuming API payloads, config files, or sensor data with measurements, letting you enforce units at the validation boundary instead of hoping every caller remembered them.

via PyCoder's Weekly newsletter

Unit mix-ups have literally crashed spacecraft; now your Pydantic models can refuse them at the door.

Annotate a field as Annotated[Quantity, PydanticPintQuantity('km')] and inputs like 12 meters arrive auto-converted to kilometers

Validation covers string, numeric, and quantity inputs, and model_dump_json serializes quantities as readable unit strings

Installable from PyPI as pydantic-pint, MIT licensed, with docs at pydantic-pint.readthedocs.io

Early-stage solo project at version 0.4, so API stability and maintenance are open questions worth discussing

Calvin #3: How Libraries Run Rust Inside Python (With PyO3)

Pydantic v2's validation core (pydantic-core) is Rust under the hood, built with PyO3 — this post shows how that bridge actually works via a small hand-built JSON parser

Four steps to get Rust into Python: write a normal Rust module, annotate with PyO3 macros (#[pyfunction], #[pymodule]), compile/install with maturin, then just import it

The parser builds a Rust tree first — Python never touches it until the boundary crossing

Key insight: converting the Rust result into Python objects (.into_pyobject) is often the expensive part, not the parsing — 100,000 JSON values means ~100,000 Python objects built after parsing's already done

Errors cross the boundary too: Rust's typed errors convert into real Python exceptions (ValueError, FileNotFoundError) via From/?, so callers get clean Python semantics

Takeaway for anyone porting Rust in: if you're returning a scalar, don't sweat it; if you're returning a big structure, profile the boundary — that's the real cost, not the algorithm

Michael #4: AWS acquires DuckLabs

Thank you Dylan McConnell.

What does this mean for the DuckDB ecosystem?

DuckDB is the open-source in-process analytical SQL engine. MIT licensed. The IP is not owned by any company - it's held by the nonprofit DuckDB Foundation, which was created when the team spun out of CWI Amsterdam. Peter Boncz, the CWI representative on the Foundation board, describes it as the entity that holds all IP of open-source DuckDB.

DuckLabs (ducklabs.com) is the company, formerly branded DuckDB Labs. Founded a little over five years ago by Hannes Mühleisen and Mark Raasveldt to give the DuckDB team a stable long-term home, bootstrapped deliberately instead of taking VC, grown to 30+ people in Amsterdam, funded by support and feature-prioritization contracts. It employs the core devs. It does not own DuckDB.

DuckLake is one of three projects DuckLabs builds, what they call the Duck Stack: DuckDB, DuckLake, and Quack. DuckLake is the lakehouse format that puts catalog metadata in a SQL database instead of in files on object storage. Quack is newer - an RPC-style protocol that turns DuckDB into a client-server system where both ends are DuckDB instances, slated to stabilize in DuckDB v2.0 in September 2026.

MotherDuck is a separate Seattle company, Jordan Tigani's, selling serverless hosted DuckDB. It was started in partnership with DuckDB Labs and has worked closely with Hannes and Mark for four years. It contracted DuckLabs for engineering work and contributes heavily upstream - three of its engineers are among the top 10 outside contributors to DuckDB. It also sells its own DuckLake offering. Customer and collaborator, never owner.

What the AWS post changes. Amazon bought the company, not the project. DuckLabs joined AWS effective September 1, with the process concluding August 31, 2026. Hannes and Mark keep leading the team and the project's technical direction, the team stays in Amsterdam, and DuckDB stays MIT under the Foundation. AWS gets the people and a direct line to the roadmap. The license protects your code, not your priorities.

Three second-order effects worth tracking:

The Foundation board is the real question. It has three directors: Mühleisen, Raasveldt, and Boncz. Two now work for AWS. Commentary on the deal has focused on exactly this - the license protects the code, not the roadmap. The announced counterweight is governance: a technical advisory board on the Foundation, and opening the extension stack so extensions signed by other developers can run in DuckDB.

MotherDuck immediately moved into the business DuckLabs vacated. It now sells DuckDB enterprise support, which it had avoided because it didn't want to compete with DuckLabs' business model, and says it has explicit blessing from Hannes and Mark now that they're joining Amazon. It also bought Tower.dev the day before the AWS announcement.

Everyone expects an AWS DuckDB service. Tigani says Amazon will likely release one eventually, and welcomes the competition, citing Redshift's failure to slow Snowflake on AWS. The groundwork is already visible: Amazon Quick uses DuckDB to query S3 Tables and has processed over 2.5B queries with it since launching in October 2025.

The DuckLake angle is the one to watch. AWS is heavily committed to Iceberg through S3 Tables, and it just acquired the team behind a competing lakehouse format. The stated plan is to use DuckDB, DuckLake, and Quack together to power a new generation of data services, but which format wins internal priority is unannounced.

Extras

Calvin:

astral-sh/uv 0.12.12: code-signed release binaries 🥳

Michael:

My MacBook power supply rebooted to install updates (?!?)

The Story of VS Code | Official Documentary

Amazon/AWS acquires DuckLabs (see recent episode on DuckLake)

Joke: We’re agentic now

Topics covered in this episode:

EuroPython 2026 videos are online

The State of Django 2026: Boring is so back

htmx 4.0.0 has been released

🐍 Functionally Zen

Extras

Joke

Watch on YouTube

Sponsored by us! Support our work through:

Our courses at Talk Python

Consulting from Six Feet Up

Connect with the hosts

Michael: Mastodon / BlueSky / X / LinkedIn

Calvin: Mastodon / BlueSky / X / LinkedIn

Show: Mastodon / BlueSky / X

Join us on YouTube at pythonbytes.fm/live to be part of the audience. Usually Tuesday at 7am PT. Older video versions available there too.

Finally, if you want an artisanal digest of every week of the show notes in email form? Add your name and email to our friends of the show list, we'll never share it.

Michael #1: EuroPython 2026 videos are online

The EuroPython Society has published all 117 recordings from EuroPython 2026 on the official EuroPython Conference YouTube channel. The conference ran July 13-19 in Krakow, Poland and celebrated the conference series' 25th anniversary. The playlist covers keynotes, panels, lightning talks, and full talk recordings across Python core, web, DevOps, data/ML, embedded, and other tracks.

If you missed EuroPython 2026 in Krakow, this is the complete free on-demand archive of one of the year's biggest European Python events.

117 videos now live on the EuroPython Conference YouTube channel, last updated Aug 17, 2026.

Michael’s personal watch list.

Calvin #2: The State of Django 2026: Boring is so back

State of Django 2026 (JetBrains/DSF survey, ~3,500 devs, 40+ countries) - "boring is so back": Django's core stays reliable while everything around it moves fast

Core is stable: Postgres 76–79% for 5 years running, templates ~80%, 43% already on Django 6.0

AI is routine now (only 10% use none) but workflow's unsettled - Claude Code leads at 35%, and 56% still just use it for chat, not autonomous edits

Tooling is consolidating: uv and Ruff both at 43% adoption, each replacing several older single-purpose tools

Type hints are winning (57% use them) but the checker is up for grabs - IDE-built-in leads at 40%, Mypy 32%, with ty/Pyrefly emerging

Two Django communities coexist happily: 72% server-rendered templates vs. 53% API-only - and htmx adoption jumped from 5% to 34% in five years

Michael #3: htmx 4.0.0 has been released

After 8 months of work, the htmx team shipped 4.0.0, a rewrite that moves internals from XMLHttpRequest to fetch() while keeping the API almost identical to htmx 2. Three changes may need action: attribute inheritance is now explicit via an :inherited suffix, event names follow a htmx:phase:action pattern, and history no longer caches pages in localStorage. Additions include built-in morph swaps, the new hx-partial tag, and many core extensions. htmx 2 stays supported and remains latest on npm until early 2027.

htmx is the go-to frontend layer for Python server-rendered apps (Flask, Django, FastAPI), and 4.0 is deliberately low-drama: nearly behavior-compatible, so teams can upgrade on their own schedule and pick up morph swaps and streaming extensions.

Explicit inheritance is the biggest migration item: hx-confirm, hx-headers, hx-target and friends no longer cascade to children unless you append :inherited; hx-disinherit and hx-inherit are gone

A CLI upgrade checker (npx htmx.org@4.0.0 upgrade-check) flags spots needing :inherited, renames like hx-disable to hx-ignore, removed attrs like hx-vars, and old event names in templates and JS

Events follow htmx:phase:action (htmx:beforeRequest becomes htmx:before:request); most error events collapse into htmx:error and htmx:xhr:* events are removed with XMLHttpRequest

History no longer snapshots pages in localStorage; back navigation re-fetches and swaps into the body, fixing a chronic support headache, with a new hx-history-cache extension for sessionStorage caching

New features: out-of-the-box morphing swaps, the [HTML_REMOVED] tag for multi-element updates, streaming over SSE/WebSockets/multipart, and hx-live, their Alpine-inspired DOM scripting solution

No forced upgrade: 2.x stays latest on npm until early 2027 (4.0 remains next) and is supported indefinitely; the team even ships official LLM skill files for guidance and upgrading

Calvin #4: 🐍 Functionally Zen

Functionally Zen (Kyle Adams, Test Double) - riffs on "simple is better than complex" with 7 extra tenets for Python simplicity

Core claims: idiomatic > non-idiomatic, data > functions, pure functions > impure functions > classes

Favorite example: a medical-dosage calculator replaced with a plain lookup dict - no logic, no tests needed

Big idea: keep a thin "impure shell" around a "pure core" (Gary Bernhardt's functional core / imperative shell) - push side effects (API calls, DB, files) to the edges

Side note: constructors that do I/O are "poison pills" - the side effect infects every class that depends on them

Payoff: pure functions and no-mock tests are just easier to read and reason about than the alternative

Extras

Calvin:

uv ships trusted-publisher token revocation and Python 3.15 support

Making a Python interpreter in 1024 bytes

Michael:

Steering council voting is now open

Joke: Makes you look like this?

Topics covered in this episode:

OpenAI's Python SDK has migrated to HTTPX2

TMOG - Native Task Manager for macOS, Windows, and Linux

wrapture - one wrapper for mocking, tracing, and observability

linkedin2md: turn your LinkedIn export into 40+ Markdown files

Extras

Joke

Watch on YouTube

About the show

Sponsored by us!

Support our work through:

Our courses at Talk Python

Consulting from Six Feet Up

Connect with the hosts

Michael: Mastodon / BlueSky / X / LinkedIn

Calvin: Mastodon / BlueSky / X / LinkedIn

Show: Mastodon / BlueSky / X

Join us on YouTube at pythonbytes.fm/live to be part of the audience.
Usually Tuesday at 7am PT.
Older video versions available there too.

Finally, if you want an artisanal digest of every week of the show notes in email form?
Add your name and email to our friends of the show list, we'll never share it.

Calvin #1: OpenAI's Python SDK has migrated to HTTPX2

The OpenAI Python SDK has migrated to HTTPX2, the Pydantic-stewarded fork of httpx.
Pydantic picked it up citing "limited activity recently" in the original project, promising "a reliably maintained path forward."

If you just use the default client, nothing to do.
No code changes.

The catch is TLS.
Quoting the guide: HTTPX "previously verified certificates against the CA bundle provided by certifi.
HTTPX2 instead uses the operating-system trust store, and the SDK no longer installs certifi."

That "can break certificate verification in minimal container images without system CA certificates, environments using corporate TLS-inspecting proxies, and deployments that relied on a custom or modified certifi bundle."

The fix is SSL_CERT_FILE or SSL_CERT_DIR, or pass your own ssl.SSLContext via verify.

Deeper integrations need real edits: custom clients, auth handlers, hooks, and request mocking all take HTTPX2 objects now, and plain httpx is no longer pulled in transitively.
So import httpx in your own code means declaring it yourself or moving over.

Temporary escape hatch: a legacy HTTPX client

Michael #2: TMOG - Native Task Manager for macOS, Windows, and Linux

A native, deeply instrumented system monitor for macOS, Windows, and Linux, now in public beta - from Plummers' Software, i.e. Dave Plummer, who wrote the original Windows Task Manager and donated it to Microsoft in 1995.
Wikipedia

Three real native apps: Swift/AppKit on macOS, Win32 on Windows, C++/Qt 6 on Linux, with a shared C++ core keeping metric semantics aligned - no browser shell anywhere.

One dense summary: CPU, clocks, thermals, GPU, memory, storage, network, energy, and the processes responsible for the load, all click-through.

Per-core honesty: logical processor and NUMA views, P and E cores color-coded, optional kernel time, 60 FPS live meters.

Memory with context: pressure, wired, compressed, cached, committed, available, and swap, plus configurable scrolling history.

Processes that act like processes: tree view, filtering, sorting, follow mode, and native verbs including service and launchd control.

Phosphor themes: light, dark, green, amber, blue, or mono, with color and saturation you tune yourself.

Calvin #3: wrapture - one wrapper for mocking, tracing, and observability

Graham Dumpleton, author of wrapt and the original New Relic Python agent, has released wrapture.
The name is wrapt plus capture.
The core idea: wrap real code instead of replacing it, so the real code still runs while you watch every call.

Name a method with wrapture.binding(Class, "method"), open a timeline(), and you get a tape of what actually happened.
Real return values, real nesting, arguments normalised against real signatures.
tape.tree() prints the call graph as it ran.

One mechanism, three jobs: monkey patching with a real lifecycle (apply, remove, suspend, plus returns, raises, transforms_args), unit testing that asserts on real call flow instead of a flat MagicMock call list, and ad-hoc tracing of a running app.

The testing pitch is error paths.
Inject TimeoutError at the payment gateway, then assert the ledger was never written.
Stubs and mocks are strict and spec-required, and there is deliberately no bare Mock().

Tracing needs no code at all.
A wrapture.toml naming targets and a sink, run with python -m wrapture main.py, and you get a live call tree with timings.
It captures ordinary logging calls as nested events, and with the otel extra it exports spans, metrics and correlated logs with W3C trace ids that join across services.

Every line of code and docs was AI-written under their direction, and they say so up front.
Two weeks from first commit, eleventh alpha, over 1000 tests, 150+ pages of docs.
Alpha on PyPI, needs Python 3.12+ and wrapt 2.4.0+.

Michael #4: linkedin2md: turn your LinkedIn export into 40+ Markdown files

Via Juan Manuel Daza - a Python CLI that unpacks LinkedIn's data-export ZIP into clean, per-category Markdown you can drop straight into an LLM.

One command: linkedin2md Complete_LinkedInDataExport.zip, plus o for output dir, -lang en|es, and -pdf.

40+ output files: profile, experience, education, skills, connections, posts, comments, reactions, recommendations, endorsements, job applications, even ad targeting and LinkedIn's inferences about you.

Built for LLM analysis: the README pitches NotebookLM, Claude Projects, Obsidian, and Ollama, with example prompts like "what patterns do you see in my career transitions?"

PDF resume mode: -pdf renders an A4 CV via weasyprint, and degrades gracefully to Markdown-only if it isn't installed.

Dependency note: "pure Python / zero-dep" holds for the Markdown path only - the PDF path needs weasyprint and markdown installed.

Install: pipx install linkedin2md recommended, pip in a venv otherwise - 86% Python, 10 releases, v0.3.1 in May.

Agentic dev angle: repo ships opencode config and an N3RV subagent pipeline, including a "judgment day" dual-model adversarial PR review.

Extras

Calvin:

EVE Online Migrates to Python 3

Michael:

Dinkus by Will McGugan

Joke: Tao of Programming: Book 5 Maintenance

Topics covered in this episode:

Web UIs for your reverse proxy

Wagtail 8.0 is hot off the presses

RISC-V is now officially supported by CPython

Django’s annual releases make every version an LTS

Extras

Joke

Watch on YouTube

About the show

Sponsored by Logfire from Pydantic: pythonbytes.fm/logfire

Connect with the hosts

Michael: Mastodon / BlueSky / X / LinkedIn

Calvin: Mastodon / BlueSky / X / LinkedIn

Show: Mastodon / BlueSky / X
Join us on YouTube at pythonbytes.fm/live to be part of the audience. Usually Tuesday at 7am PT. Older video versions available there too.
Finally, if you want an artisanal, hand-crafted digest of every week of the show notes in email form? Add your name and email to our friends of the show list, we'll never share it.

Michael #1: Web UIs for your reverse proxy

Traefik, nginx, and Caddy all sit in front of a lot of self-hosted infrastructure, and all three are configured by hand-editing files. Three active projects put a control plane on top: Traefik Manager (Python + Flask), Nginx UI (Go + Vue), and caddy/ui (React + Node). All three are additive rather than replacements - none of them take ownership of your config away from you - which is the part that matters when the thing has write access to production routing.

Traefik Manager is the Python one: Flask 3.1 and Gunicorn for the control plane, a lightweight Go agent for remote instances, currently v1.10.0 with an Android companion app.

Nginx UI is a single Go binary at 11.3k stars, with a block-style config editor, an Ace editor doing LLM completion on nginx syntax, and an MCP server so agents can drive it.

caddy/ui runs as two containers next to your existing Caddy, reads and writes your Caddyfile directly, and uses Caddy's /adapt API to validate before reload - no Docker socket required.

Each one edits the config the underlying server already reads, so your files stay the source of truth and you can drop the UI without unwinding anything.

Undo is a first-class feature across all three - timestamped backups with optional Git history, config version compare and restore, Caddyfile snapshots with one-click rollback.

Observability is where they diverge: Traefik Manager does CrowdSec and a visual route map, Nginx UI does server metrics, caddy/ui streams access logs over SSE and pulls p50/p95/p99 off Caddy's Prometheus endpoint.

Maturity spread is wide - Nginx UI has 11.3k stars, caddy/ui has 4 and was built in a single Claude session - and caddy/ui ships with auth off by default, so set CADDY_UI_USER and JWT_SECRET before it goes anywhere near a public interface.

Calvin #2: Wagtail 8.0 is hot off the presses

Link: https://github.com/wagtail/wagtail/releases/tag/v8.0

Custom base page models are now supported, so projects aren't locked into subclassing Wagtail's Page as shipped (Matt Westcott).

New v3 REST API handles both read and write CMS operations, a first for Wagtail's API.

A global registry for permission policies, plus full customizability for the remaining page views via PageViewSet.

AVIF and WebP images are no longer auto-converted to PNG by default, a real behavior change to watch on upgrade.

Five security fixes: page admin API restrictions, document identification by SHA1 hash, descendant collections in the Documents/Images API, snippet copy permissions, and the page translation endpoint.

Formalized Django 6.1 support, and CI now runs on uv with a lockfile.

Sponsor: Logfire from Pydantic

Your AI agent failed at 2am. Was it the model? A tool call? The database? Most observability tools can't tell you, because they only see part of your stack.
Pydantic Logfire sees all of it. One trace across your agents, LLMs, APIs, and database. Down to the infrastructure: services, Kubernetes, and hosts.
It's built on OpenTelemetry, with SDKs for Python, TypeScript, and Rust, and it works with any OTel-compatible language.
Every prompt, token count, and cost, right next to your vector searches and API calls.
You query everything with Postgres-compatible SQL. And so can your coding agent, through the Logfire MCP server.
Stop guessing. Read the trace.
Pydantic Logfire. AI, it's still just engineering.
Visit pythonbytes.fm/logfire today and sign up today. Get 10M records free every month, no card required. You can even click “Onboard with your coding agent” to copy a prompt to have claude or codex integrate Logfire into your app.
Thanks to Pydantic for supporting the show.

Calvin #3: RISC-V is now officially supported by CPython

Link: https://blog.python.org/2026/08/riscv-now-officially-supported/

CPython added RISC-V as a tier 3 platform under PEP 11, specifically the 64-bit Linux target riscv64-unknown-linux-gnu.

RISC-V is an open ISA anyone can implement, unlike x86 and ARM, and its market is projected to quadruple by 2032.

The RISE Project donated real RISC-V machines for buildbots; the author's work was funded by a Sovereign Tech Agency fellowship.

What changes: the port is now a maintained compatibility target, so CPython changes are less likely to quietly break it. What doesn't: no python.org installers, no binary wheel parity for native extensions.

Next up: RISC-V runners in CPython CI for pre-merge feedback, then a push toward tier 2, plus architecture-specific optimizations.

The ask is testing. If you have RISC-V hardware, build CPython, run your test suite, file what breaks.
Tier 3 is the weakest support tier. PEP 11 tier 3 requires a core developer contact and a buildbot, but failures on tier 3 platforms explicitly do not block a release. Saying "ongoing CI/testing expectations" oversells it. The honest bit is "someone is now on the hook for it, and breakage gets noticed," not "it's guaranteed working."
Worth the caveat that this is Linux SBCs, not microcontrollers. A VisionFive 2 counts, an ESP32-C6 or Pico 2 does not. Those are 32-bit non-Linux parts where MicroPython is still the answer.

Michael #4: Django’s annual releases make every version an LTS

Starting with Django 2028, Django will move to one January feature release per year, adopt calendar-based version numbers, and support every release for three years. The old distinction between standard and LTS releases disappears, giving teams a predictable annual upgrade path that aligns more closely with Python’s own release and support cadence.

Every Django release becomes the safe, long-supported choice, so teams no longer need to wait for a specially designated LTS version or absorb two years of changes at once.

Each release gets one year of mainstream bug fixes followed by two years of security and data-loss fixes.

New releases support the three latest Python versions and add the next Python release during their first year.

Calendar versioning begins with Django 2028, followed by Django 2029 and so on.

Three Django versions will be supported at any time, giving third-party packages a clearer rolling target.

Nothing changes before 2028, and existing commitments for Django 5.2 LTS and 6.2 LTS remain in place.

Extras

Calvin:

The Python docs now document the time complexity of built-in types
https://docs.python.org/3.16/library/time-complexity.html

Thinking in Python - Bruce Eckel's free book
https://thinkinginpython.com/
Michael:

prune_uv_pythons.py - Prune uv-managed Python installs, keeping only the newest patch per minor version

Runs automatically in my system “upgrade” script: upgrade-output-2026.png

Started using Ollama cloud models for my Hermes assistant. Thanks to Jeff Triplett I learned they are not just local models.

Joke: The Tao of Programming - Book Seven: Corporate Wisdom

Topics covered in this episode:

Python 3.12.14, 3.11.16, 3.10.21 - security releases

Codeberg’s AI-code ban tests its role as a GitHub alternative

Brett Cannon: what's missing for reproducible builds on PyPI

nothing records the source code a distribution came from. direct_url.json captures it when you install from a repo or archive, so the fix is putting the same info in sdist/wheel metadata.

recording the build tools. Wheels can already do this via PEP 770 SBOMs in .dist-info/sboms/ - sdists can't, since they're a tarball plus a precalculated PKG-INFO with nowhere to hang extra metadata. Either "don't use sdists" or an sdist v2.

Extra extra extra, hear all about it

Extras

Joke

Watch on YouTube

Sponsored by Logfire from Pydantic pythonbytes.fm/logfire

This episode is brought to you by Pydantic Logfire. It's observability for AI apps from the team behind Pydantic - agents, LLMs, APIs, database, and infrastructure in a single trace, queried with Postgres-compatible SQL. Your coding agent can query it too, through their MCP server. I'll tell you more later.

Connect with the hosts

Michael: Mastodon / BlueSky / X / LinkedIn

Calvin: Mastodon / BlueSky / X / LinkedIn

Show: Mastodon / BlueSky / X

Join us on YouTube at pythonbytes.fm/live to be part of the audience. Usually Tuesday at 7am PT. Older video versions available there too.

Finally, if you want an artisanal, hand-crafted digest of every week of the show notes in email form? Add your name and email to our friends of the show list, we'll never share it.

Calvin #1: Python 3.12.14, 3.11.16, 3.10.21 - security releases

https://blog.python.org/2026/08/python-31214-31116-31021/

Source-only security releases for the three branches now in security-fix-only mode; release team blamed the European solar eclipse for the timing.

tarfile hardening. Multiple path-traversal bypasses of the data filter closed, including a symlink escape that bypassed the CVE-2025-4330 fix; extract() now applies the filter to link targets too.

Four fresh CVEs: CVE-2026-2297 (SourcelessFileLoader not using io.open_code() for .pyc), CVE-2026-4224 (expat crash on deeply nested content models), CVE-2026-3644 (control chars in http.cookies.Morsel), plus the completed CVE-2021-4189 fix in ftplib.ftpcp.

Quadratic-complexity DoS cleanup across the stdlib: HTMLParser, configparser regexes, unicodedata.normalize(), csv.Sniffer.sniff(), and ElementTree XPath index predicates.

Header/injection fixes: CR/LF rejected in HTTPConnection.set_tunnel(), control chars blocked in wsgiref.handlers status, and webbrowser now rejects leading dashes (plus a %action prefix bypass).

http.client now caps chunked trailer lines and 1xx interim responses at 100 each - a hostile server could previously hang the client forever despite a socket timeout.

Memory-safety odds and ends: stale pointers in lzma/bz2/zlib decompressors after MemoryError, a bz2 stack overflow on reuse-after-error, and bundled libexpat bumped to 2.8.3.
If you're still on 3.10, 3.11, or 3.12 - and you extract tarballs from anywhere you don't fully control - this one's not optional.

Michael #2: Codeberg’s AI-code ban tests its role as a GitHub alternative

Armin’s article “Codeberg Divides”

Armin Ronacher argues that Codeberg’s new terms, which prohibit projects mostly written with generative AI, create a vague and difficult-to-enforce boundary. His larger concern is that a democratically governed host can still be unpredictable or ideologically narrow, weakening Codeberg’s potential as a broad European alternative to GitHub.

The strongest question for Python developers is whether repository hosting should judge legal open source by how code was produced, or focus on behavior and resource abuse.

“Mostly generated” is hard to measure in modern codebases where developers mix handwritten code, completions, agents, and generated refactors.

Ronacher suggests clearer alternatives: ban all LLM involvement, or target autonomous repository spam, abusive resource use, and low-quality generated contributions directly.

Codeberg is free to choose a values-driven community, but that may conflict with being predictable, neutral infrastructure and a serious GitHub competitor.

Worth discussing: can open-source communities set meaningful AI boundaries without driving maintainers and projects into opposing camps?

Very first search for these terms lands on this page.

Codeberg looked like a viable alternative. … Unfortunately, the latest update to its terms of service seems to mark a first step in changing one part I moved there for, namely the “freedom” part.

Sponsor: Logfire from Pydantic

Your AI agent failed at 2am. Was it the model? A tool call? The database? Most observability tools can't tell you, because they only see part of your stack.
Pydantic Logfire sees all of it. One trace across your agents, LLMs, APIs, and database. Down to the infrastructure: services, Kubernetes, and hosts.
It's built on OpenTelemetry, with SDKs for Python, TypeScript, and Rust, and it works with any OTel-compatible language.
Every prompt, token count, and cost, right next to your vector searches and API calls.
You query everything with Postgres-compatible SQL. And so can your coding agent, through the Logfire MCP server.
Stop guessing. Read the trace.
Pydantic Logfire. AI, it's still just engineering.
Visit pythonbytes.fm/logfire today and sign up today. Get 10M records free every month, no card required. You can even click “Onboard with your coding agent” to copy a prompt to have claude or codex integrate Logfire into your app.
Thanks to Pydantic for supporting the show.

Calvin #3: Brett Cannon: what's missing for reproducible builds on PyPI

Framing came out of his 2026 Python Packaging Council nomination - the secure-supply-chain gap he found is that Python has no defined way to do reproducible builds at all.

Design goal is zero friction: producers uploading to PyPI shouldn't have to do anything. The work lands on build backends and installers.

Gap #1: nothing records the source code a distribution came from. direct_url.json captures it when you install from a repo or archive, so the fix is putting the same info in sdist/wheel metadata.

Gap #2: recording the build tools. Wheels can already do this via PEP 770 SBOMs in .dist-info/sboms/ - sdists can't, since they're a tarball plus a precalculated PKG-INFO with nowhere to hang extra metadata. Either "don't use sdists" or an sdist v2.

The replay mechanism already exists: [build-system] in pyproject.toml is a defined entry point, so if backends recorded their own environment, you could reinstall and re-run the build.

Payoff idea: trusted third parties report successful reproductions back to PyPI, which displays "independently reproduced by X" - surfaced in the index API so installers could prefer reproduced files.

Explicitly framed as a perk, not a requirement - roughly SLSA build level 1, no shaming projects that don't opt in.
Verbal kicker option: "And don't think pure-Python wheels are off the hook. Something built that wheel, and if that something was compromised, so is your wheel. SolarWinds was a build-process attack."

Michael #4: Extra extra extra, hear all about it

Python 3.14.7

Upgraded the MCP servers to 2026-07-28 v2 protocols (talk python, python bytes)

Got agentsview running synced via postgres

Talk Python courses, teams trial offering

Talk Python courses, government procurement offering

Lean TDD audio book is out

Extras

Calvin:

uv now prefers post-quantum key exchange - https://github.com/astral-sh/uv/releases/tag/0.12.4

Joke: Beware of dog