505 episodios
- Topics covered in this episode:
tinyjobs: a SQLite job queue goes free-threaded
funkycache: cache Python functions in SQLite
Ghostman - a keyboard-driven terminal API client
diskcache-oxide: A shared, durable disk cache
Extras
Joke
Watch on YouTube
About the show
Sponsored by LongLink: pythonbytes.fm/longlink
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: tinyjobs: a SQLite job queue goes free-threaded
tinyjobs is a Python job queue and cron scheduler that starts with a SQLite file and no dependencies. Switch the URL to Postgres or Redis without rewriting tasks. It runs async tasks natively, embeds workers in FastAPI, and plugs into Django 6's tasks framework. The creator's free-threading audit found four races hidden by the GIL.
Background jobs without deploying a broker, plus a concrete case study in what removing the GIL exposes.
The creator reports races in the task registry, codec cache, cross-thread flag and thread pool. hiredis can re-enable the GIL; the worker warns when it detects that.
On 3.14t, --loops N runs event loops in separate threads. The author's laptop benchmark hit 42,000 async jobs/s with eight loops and two Redis instances, close to eight processes. SQLite rejects loops above one.
Clock-skew lesson: two hosts 20 minutes apart duplicated 492 of 3,000 jobs on 0.7.0. Using Redis server time fixed that test, not the general exactly-once problem.
Author's SQLite measurements: about 572 jobs/s end-to-end; a 20,000-job burst drained in four seconds. Synthetic workloads and different harnesses, not interchangeable throughput claims.
At-least-once delivery still requires idempotent tasks. Python 3.12+; young project, with the README now listing v0.11.0 versus the email's v0.9.0.
Docker setup:
services:
web:
build: .
command: uvicorn main:api --host 0.0.0.0
volumes: [jobs:/data]
worker:
build: .
command: tinyjobs worker --app tasks:app --shutdown-timeout 25
stop_grace_period: 40s
volumes: [jobs:/data]
volumes:
jobs:
external: true
Calvin #2: funkycache: cache Python functions in SQLite
Alex Chan's functools.cache-style decorator stores results in SQLite, so they survive after the process exits. He built it to speed up his static site build.
It's released on PyPI: funkycache 1.0.4, from November 15. The first release, 1.0.0, came out November 7. It needs Python 3.14+ and depends on pydantic and xxhash.
Usage: cache = FunkyCache(storage="sqlite"), then @cache.register(files=[...], values=[...]). A cache entry is invalidated when the function's source file changes or when any listed file or value changes, such as a library version.
Return values go through Pydantic's TypeAdapter, based on the return type hint, so it only works on typed code.
Generators get special handling. functools.cache hands every caller the same generator object. funkycache saves the output as a list and gives each caller a fresh iterator, up to a soft memory limit.
Cache keys are JSON hashed with XXH64. They're deliberately lossy, and that's fine because nothing reads the original arguments back out of a key.
The design notes are a good segment on their own: the author had used MD5 because they "conflated weak with fast," and in their limited testing JSON was faster than pickle and easier to debug.
With a warm cache the site builds in about half a second, and the library is only a few hundred lines including tests. It doesn't watch files on purpose, to stay small.
Calvin #3: Ghostman - a keyboard-driven terminal API client
A local-first Postman alternative that runs in the terminal, with no cloud account required. It's MIT licensed and was featured in PyCoder's Weekly #760.
It's released on PyPI: pip install ghostman, then run ghostman. The current version is 0.1.8, from November 3. The first release, 0.1.0, came out October 31. It needs Python 3.10+.
It's built on Textual, httpx and Rich, so it's pure Python under the hood.
It sends GET, POST, PUT, DELETE and PATCH requests, shows DNS and time-to-first-byte timing live, and colors JSON responses automatically.
A built-in webhook inspector: Ctrl+W starts a listener on port 9090. Captured payloads show headers and timestamps, and you can load one straight into the request editor.
Collections are plain JSON/YAML files you can commit to Git. The README gives two different folders for them (.ghostman/ and ~/.ghostman/).
It's fully keyboard-driven: Ctrl+S sends, Ctrl+K saves, Ctrl+N starts a new request, Ctrl+Q quits.
The author claims about 30MB of RAM and a cold start of about 150ms; I haven't checked either number. It's a young project, with 158 stars and 15 commits.
Michael #4: diskcache-oxide: A shared, durable disk cache
Michael's diskcache-oxide is a Rust-backed, SQLite-based cache for Python workers sharing one directory on the same machine. Entries survive process restarts without running a cache server. It keeps the familiar diskcache API, adds fork and free-threading safety, and uses msgpack or JSON by default instead of pickle.
Michael's item: a shared cache for multi-worker apps without deploying Redis or keeping a separate dict warm in every process.
Cache, FanoutCache sharding and transactions are available now. NullCache switches caching off without changing call sites; Caches manages named caches for an app.
Author's bench/gate.py, Linux container on Apple Silicon, CPython 3.14, 99:1 reads/writes: about 750k ops/s with one thread and 723k with eight; diskcache 5.6.3 falls to 44k. Not independently tested here.
Free-threading support is explicit: the Rust extension declares gil_used = false. A process-wide fork barrier protects SQLite state when workers fork.
Pickle is opt-in. Tagged serialization preserves types such as tuples, sets, datetimes and Decimals, with registration for custom types.
The docs come to about 70,000 words, the length of a typical novel. Of that, about 53,000 are the written story (guide, recipes and the home page), and the rest is API reference, the agent skill and code samples.
Early release, not full diskcache parity: string keys only; AsyncCache, memoize, tags, Deque and Index are still planned. The network cache server is a roadmap item too.
Python 3.14+; macOS and Linux wheels include SQLite. Windows support is planned. Migration changes the import and uses a new directory, not the old cache.db.
Extras
Calvin:
Django Software Foundation Board Nominations open until December 2nd
Michael:
Startpage paid plans
Test driving Helium Browser
Tallyman got a big update, give it another try
Tallyman is my command-line tool for seeing the shape of a codebase, with line counts grouped by language and categories such as Code, Docs, and Specs. Version 0.4.3 bundles new controls and a long list of fixes.
I made a bunch of massive updates this week. If you tried Tallyman before and it didn't work for your project, give it another try.
Use --no-save to try setup choices without writing a config, and --exclude PATTERN for one-run file exclusions.
Lots of fixes to gitignore handling, nested configs, the setup TUI, encodings, and image export. First runs in CI or pipes no longer hang waiting for setup.
Optional exclusion of inline Rust test code, plus MATLAB and Solidity support, bringing the language count to 44.
Want another feature? Submit an idea through a GitHub issue.
Bunny.net fonts disappoint.
Root cause: Bunny Fonts began serving its font files from cdn.jsdelivr.net, which our CSP blocks - production had silently fallen back to system fonts.
Talk Python Meetup: SQLite Might Actually Be All You Need
Jokes:
Disaster recovery
Prophecy fulfilled - Topics covered in this episode:
PyPI's redesigned project pages now warn when provenance changes
gilguard catches the import that turns the GIL back on
pip 26.3: pylock extras, and pip says plainly that untrusted wheels aren't safe
All developer tools
Extras
Joke
Watch on YouTube
About the show
Sponsored by LongLink: Open-source platform for building and running custom business applications with Python and FastAPI
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: PyPI's redesigned project pages now warn when provenance changes
Live now on pypi.org (Nov 6). Announced in July, shaped by user research, funded by OpenSSF and built by Kabu Creative.
New Security tab on every project page shows each release's provenance state and per-file attestations, with a link to the transparency log.
Two attestation types: PyPI Publish (uploaded by a Trusted Publisher) and SLSA Build Provenance (ties a file to its source commit, build platform and instructions).
"No provenance" isn't a malware flag; it means the file's origin can't be cryptographically verified. That's typical for older releases or projects without Trusted Publishing.
Four new provenance warnings: Incomplete (e.g. wheels via Trusted Publishing but sdist via API token), Inconsistent (mixed build systems or repos), Change (different repo or workflow than last release), Loss (stopped publishing attestations).
Warnings are meant to catch files that may not have come from the maintainers, such as after an account or publishing-workflow takeover. PyPI says a Change of Provenance "can also indicate a compromised pipeline or account takeover," and an unexpected Loss of Provenance should be treated "with skepticism until verified.”
Warnings now sit at the top of the page with yanked, archived and pre-release banners. A quarantine banner overrides all of them. Sidebar metadata is labeled "PyPI data" or "Data verified by PyPI."
Release files tab gets search, filters, a per-file provenance column and orange icons for "late" files (uploaded more than 14 days after release). Those only appear on releases from before July 2026, when PyPI started rejecting new files after 14 days.
Michael #2: gilguard catches the import that turns the GIL back on
gilguard catches a nasty free-threading surprise: importing a C extension without declared free-threading support can turn the GIL back on for the rest of the process. Import gilguard first and it raises a detailed error naming the extension, distribution/version, import chain, and the line of your code responsible.
A transitive dependency can undo your move to free-threaded Python. Fail at the offending import instead of discovering lost parallelism in a benchmark.
Uses import hooks plus CPython's warning path to catch GIL activation; GILEnabledError inherits BaseException, so even except Exception won't swallow it.
python -m gilguard audits installed top-level packages in fresh interpreters. Supports targeted modules and JSON output; exits 1 when it finds an offender for CI.
The audit misses extensions loaded lazily on first use. Exercise those paths in tests with gilguard installed early; one process can identify only its first GIL-flipping import.
GILGUARD_ACTION=warn reports without stopping; off permits standard builds. Default mode raises on standard Python or an already-enabled GIL. PYTHON_GIL=0 prevents activation, so the guard cannot detect offenders there.
Published on PyPI as 0.1.0. Install with uv pip install gilguard. Python 3.13+, MIT; no runtime dependencies.
Calvin #3: pip 26.3: pylock extras, and pip says plainly that untrusted wheels aren't safe
pip 26.3 released Nov 2. Its security policy now says pip "has never considered installing untrusted wheels safe," because Python's import system is dynamic, so pip can't guarantee installing a wheel won't execute third-party code (#14412).
The change: pip blocks unexpected imports during wheel installation "to avoid loading code from packages being replaced." It loads what it needs for installing and error reporting up front (PR #14247, merged Nov 2: https://github.com/pypa/pip/pull/14247).
CLI vs. library use: from the command line, imports stay blocked until pip exits. Code that calls pip programmatically gets warnings after control returns.
Rolled out in steps: pip 26.1 started warning ("Unexpected import of '...' after pip install started. pip 26.3 will enforce this behavior change"), and 26.3 turns it into an error. Tracking issue #13842 collected reports before enforcement: https://github.com/pypa/pip/issues/13842
What tripped it in the wild: a .pth startup hook at Pradyun Gedam's workplace that registers an atexit handler to report interpreter usage metrics over HTTP (https://github.com/pypa/pip/issues/13842#issuecomment-4613463933), plus warnings involving lark_oapi and rich._emoji_codes.
Escape-hatch debate: the author, Damian Shaw (notatallshaw), suggested appending module names to pip._internal.commands.install._EAGER_IMPORTS. Pradyun objected that this requires importing from pip._internal, that importing pip's install command is expensive (about 689 ms with no .pyc files and a cold filesystem cache), and that pip isn't necessarily installed in every environment. Shaw's reply: it "just moves where the import cost is," and turning the warning into an error is "crucial."
Interrupted installs: pip now writes recovery metadata and reports recovery failures and where it kept backups. An interrupted uninstall may need manual recovery, and an interrupted --target install can leave a partial target directory.
Also in 26.3: -r pylock.toml[extra1,extra2] for extras, --group pylock.toml:docs for non-default groups, --no-binary with pylock files, and pip refuses to follow an HTTP redirect to a file: URL.
Michael #4: All developer tools
HeyUtils is a collection of 306 free developer utilities in 41 categories, with no account or installation required. The full catalog covers data conversion, APIs, networking, DevOps, frontend work and binary protocols. Python developers get model generation and packaging helpers alongside the everyday formatters and decoders worth bookmarking.
One bookmark for the tiny jobs that interrupt coding: inspect a payload, compare configs, decode a token or figure out a cron schedule.
Data tools include JSON/YAML/TOML conversion, CSV joins, JSONPath and JMESPath testers, a jq playground, and a SQLite viewer with read-only queries.
Python-specific options go beyond regex: generate dataclasses or Pydantic models from JSON, check PEP 440 versions, and inspect requirements.txt or pyproject.toml dependencies.
The collection also covers JWT/OAuth debugging, DNS and TLS checks, Docker Compose, Kubernetes YAML, GitHub Actions, and frontend helpers such as color contrast checks.
Most tools process input locally, according to the site. Network tools make requests after you start them and explain what they send; don't assume every page is offline.
Generated models need review: sample data cannot describe a complete validation contract, and dataclass type hints do not validate incoming values.
Extras
Calvin:
Coldframe: a stdlib-only honeypot that poses as a supermarket fridge controller**
Michael:
Announcing new Security Developer at the PSF
Brett Smith is joining the PSF as a Security Developer, a new role funded by Anthropic. He'll work with Seth Larson and Mike Fiedler on vulnerability response and PyPI malware removal, with more time for proactive work as the team's workload grows.
More paid security capacity for the Python and PyPI infrastructure we depend on every day.
The PSF reports 3-4x the volume of reports and CVEs for Python and pip compared with a year ago.
Malware published and removed from PyPI is up 60% year over year. That's a workload measure, not a claim that 60% more packages are malicious.
Planned work includes scaling PyPI's autonomous quarantine program and streamlining how the Python Security Response Team handles reports.
Smith brings software development and Linux administration experience, including work at W3C and Software Freedom Conservancy.
Joke: No papa - Topics covered in this episode:
Your GitHub language bar is lying (how to fix it)
Python Typing Survey 2026: developers mix type checkers, and AI is writing the hints
Flask Vibe - Build Apps You Can Understand
Python on my wrist: MicroPython on a PineTime
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, 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: Your GitHub language bar is lying (how to fix it)
GitHub's language bar comes from Linguist, which counts every tracked byte in the repo. Michael's chameleon-rs project read as 75.5% HTML because committed docs-site output and test suites outweighed the Rust engine. Three .gitattributes attributes changed the story: linguist-generated for build output, linguist-vendored for an upstream test suite, and linguist-detectable=false for tests and benchmarks on both sides. The bar now shows the real mix, roughly 62% Rust and 38% Python.
That bar is one of the first things people see on your repo; if generated files skew it, a few lines of .gitattributes tell the truth.
The bar is byte-proportional, so a 9 MB committed docs build can make a Rust project read as mostly HTML
linguist-generated hides build output and collapses those diffs in pull requests too
linguist-vendored covers copied-in code; linguist-detectable=false drops anything from the stats
chameleon-rs went from 75.5% HTML to roughly 62% Rust and 38% Python after a few lines of config
Tests and benchmarks were excluded symmetrically, on both the Rust and Python sides, so neither skews the ratio
Check patterns before pushing with git check-attr; GitHub recalculates a few minutes after the push
Calvin #2: Python Typing Survey 2026: developers mix type checkers, and AI is writing the hints
Meta's 2026 Python Typing Survey results: 1,794 responses, Aug 5 - Sep 2. Pyrefly (Meta), JetBrains, Microsoft and Astral's ty team helped write it.
Typing is stable: 85.5% use hints often or always (88.0% in 2024). Which checker people use is not stable.
49.9% run two or more checkers (46.0% in 2025), and 83.3% of Pyrefly users also run another one. Speed is the top reason for picking a checker (56.5%).
Checkers disagree: 33.3% report inconsistencies between them, rising to 42.7% among multi-checker users.
AI is writing the types: 42.5% had AI write hints, and 38.4% say types make AI code more reliable (18.5% last year).
29.8% are "not sure" whether types help AI-assisted coding, about 4x the uncertainty on any other benefit.
Help sources flipped: Stack Overflow 46.4% to 22.9% and LLM chat 26.0% to 41.7%, 2024 to 2026.
Top pain is still missing library types (65.1%; Django, SQLAlchemy, pandas, NumPy). The most-wanted feature is better Callable syntax (45.7%). Raw data zip is linked.
Michael #3: Flask Vibe - Build Apps You Can Understand
Flask Vibe is a new tutorial site from Frederick Tubiermont, a developer who started coding at 47 and builds with Flask, PostgreSQL, raw SQL, and vanilla JS. The pitch: AI assistants generate more reliable, easier-to-verify code when the stack has no build step, no ORM, and no hydration. It ships a manifesto, tutorials on modular vanilla JS and AI-friendly coding patterns, and a Flask plus psycopg2 CRUD walkthrough.
For vibe coders burned by Next.js defaults on Lovable or Replit, this is a concrete, opinionated case that simpler Python stacks pair better with AI-generated code.
Claims a structural 1.8x LCP win over Next.js on the same dashboard app: 905ms vs 1.66s, both scoring Lighthouse 100
Tutorials cover modular vanilla JS, AI-friendly coding patterns, and Flask CRUD with raw psycopg2 SQL and no ORM
Creator started Python at 47 in 2022 and runs the site on the stack it teaches; the homepage is 42 KB with Lighthouse 100
Solo London-based project (adsyme Ltd), launched via an r/flask self-post in February 2026; early, opinionated, and the benchmark leans on one self-run comparison with its methodology published on site
Calvin #4: Python on my wrist: MicroPython on a PineTime
Michiel (Python Leiden user group) runs MicroPython on a PineTime, Pine64's ~$26 open smartwatch: 64 MHz Cortex-M4, 64 KB RAM, 512 KB flash.
He revived wasp-os, a dormant MicroPython watch OS stuck on a 2019 MicroPython fork whose maintainer is asking for new maintainers (issue #536).
The build is now one command with uv. Bluetooth flashing uses bleak instead of the deprecated gatttool, cutting update time from over 8 minutes to about 3.5.
Free RAM at boot went from 7.1 KB to 12.4 KB by using the flash chip's real 4 KB blocks. He also added a watchdog, plus vibration, touch and I2C dead-battery fixes.
His three upstream PRs (frozen native code, PWM, ADC sample time) are merged, so wasp-os now runs on mainline MicroPython. They're targeted for MicroPython 1.30, planned for December.
New faces: a Dutch week clock, and an 8-bit pixel clock that draws its digits without any font data and shows a live Unix epoch counter.
The Guido app: a 16-color, 80x80 run-length-encoded portrait (photo by Kushal Das, CC BY-SA). All four images total under 12 KB, versus 112 KB for one raw screen.
Next up is the PineTime Pro (AMOLED, GPS, dual-core M33), with no release date yet. Code is on the pinetime-upstream-micropython branch of mbeijen/wasp-os.
Extras
Calvin:
PyPI now caps version strings at 128 characters — https://blog.pypi.org/posts/2026-10-23-version-length-limit/
Wagtail Space — https://wagtail.org/wagtail-space-2026/
Michael:
Thanks Hugo: Lots of Python releases for Cybersecurity Awareness Month
Talk Python Meetup: Talk Python in Production: Building Your Own Infrastructure
Joke: Binging red buttons - Topics covered in this episode:
PHP wasn’t the only problem last week
chameleon-rs
Bringing uv and ty together
Stlite runs Streamlit apps entirely in the browser
Extras
Joke
Watch on YouTube
About the show
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: PHP wasn’t the only problem last week
Three security incidents in one week, each at a different layer: CA trust (eMudhra), the release pipeline (LiteLLM) and a C decoder (Brotli). All three have fixes released.
eMudhra CA: the keys of a compromised eMudhra intermediate CA are now distrusted by CPython. 3.15.1, 3.14.9 and 3.13.17 shipped Oct 21. 3.15.2, 3.14.10, 3.13.18, 3.12.16 and 3.11.18 followed Oct 26 (CVE-2026-115557) and also fix a tarfile filter bypass. Python's post says pip operations are safe even before pip is upgraded.
eMudhra, tooling: pip 26.2.2 bundles certifi 2026.10.19, which removes the root. uv 0.13.4 (GHSA-hq85-5cpj-mr62) and 0.13.5 (rustls-webpki 0.103.16) are the uv fixes. After upgrading uv, run uv python upgrade. Existing venvs need pip upgraded by hand, and the 3.9 and 3.10 builds still bundle a pip that trusts the root.
Anyone holding those intermediate keys can mint certificates for any domain that an unpatched client will accept as valid.
That enables man-in-the-middle attacks: reading or altering HTTPS traffic without a certificate warning.
The risk is highest where the attacker can sit on the network path, such as hostile Wi-Fi, a compromised router or ISP, or a cloud network position.
For Python specifically, the exposed traffic would be package downloads from PyPI, API calls with credentials or tokens, and webhooks. A tampered package download is the worst case.
Containers and old venvs that nobody rebuilds are where this lingers. uv says its Python 3.9 and 3.10 builds still bundle a pip that trusts the root, and existing venvs don't pick up the fix automatically.
LiteLLM 1.107.0: malicious wheels hit PyPI on Oct 21. All seven wheels were live from about 11:40 to 13:23 UTC, with roughly 49k downloads. The Docker images were also infected. It's the second LiteLLM compromise this year, after 1.82.7 and 1.82.8 in March.
LiteLLM payload: cook.pth runs on every Python start, so nothing has to import litellm. It steals SSH, cloud, browser, CI and AI-tool credentials, and an hourly loader runs remote code. The clean pin is litellm==1.106.4. Kill the loader first, rebuild rather than repair, then rotate everything the host could reach.
LiteLLM root cause: a master key committed to a public repo on May 27 was never revoked. On Oct 10 it yielded an org owner's GitHub CLI token. The attacker then changed the trusted release workflow to build from a lookalike Berri-AI/litellm repo. BerriAI's first explanation (tokens in logs) was wrong, and the Oct 23 report supersedes it.
Broccoli2Shell: CVE-2026-111497 is an out-of-bounds write in Google's Brotli C decoder. It affects the Python Brotli and brotlicffi packages 1.0.3 through 1.2.0(.x). Upgrade to Brotli 1.2.1 or brotlicffi 1.2.1.0. The CVE was published Oct 22 and rated 9.2 Critical by GitHub.
Broccoli2Shell workaround: if you can't upgrade, uninstall both packages. urllib3, requests and aiohttp then fall back to gzip and deflate. Also reject Content-Encoding: br request bodies at the proxy or WAF.
Sources
https://blog.python.org/2026/10/python-3152-31410-31318-31216-31118/
https://www.stepsecurity.io/blog/litellm-1-107-0-compromised-pypi-backdoored-wheels-credential-stealer
https://broccoli2shell.com/
Michael #2: chameleon-rs
Chameleon templates, much faster than before (up to 70x faster on start)
Modernized: A Rust engine that runs your Chameleon templates unchanged with async rendering, partials (think HTMX), Markdown
Built-in framework support: Flask, Quart, FastAPI, Starlette, Pyramid, Robyn and Litestar integrations.
A compatibility shim for testing out quickly: chameleon_rs.compat.install()
AI agent support via docs (every doc page has a .md extension variant, eg FastAPI docs) and the skill is installable or downloadable.
Byte-for-byte identical on every page for talkpython.fm and training.talkpython.fm
Passes 100% of the unit tests of the original chameleon project. See compatibility page.
Natively supports my chameleon-flask, fastapi-chameleon, and chameleon-partials libraries.
Swapping Talk Python Training to chameleon-rs made it 20% fast (end-to-end, not just template rendering)!
Calvin #3: Bringing uv and ty together
Status: Astral (Sara Sklenka, Oct 13) announced "an experimental integration between uv and ty, available in preview." They ask for feedback, and say "in parallel, we're continuing toward ty's stable release."
uv check: a new uv command that prepares the project environment, installs dependencies and runs ty. Flags are --package [HTML_REMOVED], --all-packages and --script example.py. Ruff support is planned, so lint and type check would run in one command.
Lockfile pinning: uv check uses the ty version recorded in your lockfile. Developers and CI therefore share one ty version without separate pins.
PEP 723 scripts: ty reads inline script metadata and uses uv to build an environment per script. Each script is checked against its own declared dependencies, even when they differ from the project's. In the editor, saving a script syncs it with uv.
Enabling it: running uv check turns it on automatically. In VS Code, install the astral-sh.ty extension and set "ty.experimental.useUv": "on". On the command line, run TY_UV=scripts ty check.
Opt-in: the post says automatic environment setup "is currently opt-in" because installing dependencies can execute third-party code. Astral plans to enable script support by default over time, and automatic setup for standard projects.
Under the hood: it's powered by uv workspace metadata. uv 0.13.6 (Oct 26) changed that preview output to nest each module's owners in an object, so anything parsing the old flat structure breaks.
Versions: it needs uv 0.12.3+ and ty 0.0.76+. Current releases are past both (uv 0.13.6, ty 0.0.92 on Oct 26), though I couldn't confirm 0.0.76's exact date.
Next: Astral says it's working on checks that combine uv's dependency knowledge with ty's code analysis, such as detecting unused dependencies.
Also credit to listener Sky Kasko. :)
Michael #4: Stlite runs Streamlit apps entirely in the browser
Streamlit is a very unique way to create data-driven dashboards. Stlite is a WebAssembly port of Streamlit built on Pyodide, so a Streamlit app runs completely in the visitor's browser with no Python server behind it. It ships as three packages (@stlite/browser for web pages, @stlite/desktop for offline desktop apps, @stlite/react for embedding in React), plus Stlite Sharing, a hosted editor for trying apps online. The project has been active since 2022 and is now at 0.85.1 with sponsorship from Streamlit/Snowflake and TestMu AI.
A Streamlit app becomes static files you can host anywhere, the same story JupyterLite tells for notebooks.
Deployment shrinks to a script tag or a single HTML file; the server only serves static assets and never runs Python.
It patches requests and urllib through pyodide-http and supports pyfetch, so most existing HTTP code keeps working.
Real limitations: time.sleep is a no-op in favor of asyncio.sleep, asyncio.run breaks, and packages with unported binary extensions cannot install.
Files default to ephemeral memory, but IDBFS mountpoints persist data across reloads in the browser's IndexedDB.
A SharedWorker mode lets multiple apps share one Python runtime to cut memory, at the cost of shared state between apps.
The @stlite/desktop bundler turns an app into an offline desktop executable, demonstrated converting Streamlit apps to .exe files.
Extras
Calvin:
Real Python Podcast #316 with Seth Larson on Python security
**PSF wikis relaunched on GitHub Pages**
Michael:
PHP ships emergency patches for critical PHP2Shell flaws
OpenAI released a checker
Talk Python Next Tech Talk: Talk Python in Production(v2)
Notable ZeroVer Projects via Vincent Poulailleau
Python 3.15.2 is out
Joke: captcha: too real! - Topics covered in this episode:
Nod: pause your Python program and open a notebook at any line
Polars 2.0 ships: streaming engine by default, spill-to-disk, and a row-order gotcha
django-cachalot caches your ORM queries and invalidates them for you
Towards async transactions in Django
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, 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: Nod: pause your Python program and open a notebook at any line
Nod (Notebooks-on-Demand) is a JupyterLab extension by Eric Rawn that drops a notebook into a running Python program. Add a notebook() call anywhere, run the program with nod, and execution pauses there with a notebook containing all variables at that point in the call stack. Edits go back to the source file with a button, with cells converted to code and markdown to comments via Jupytext.
It answers the classic 'this would be easier in a notebook' debugging moment without copying snippets out to files.
Like a breakpoint with a notebook inside: the left panel walks the call stack and notebook state switches with it
Install is pip install nodpy plus nod --install-kernel, then run with nod python -m myfile
The round trip back to source is the differentiator; markdown cells become comments, cells become newlines, and notebooks are disposable since the source file recreates them
nodLog() stashes variable values across calls to explore later; the article also pitches notebook() for stepping through AI-generated code line by line
Early stage: repo from December 2025 with 16 stars and essentially one contributor, so expect rough edges
Calvin #2: Polars 2.0 ships: streaming engine by default, spill-to-disk, and a row-order gotcha
Polars 2.0 released Oct 6, 2026 (Ritchie Vink). The post says it's "not intended to be a big feature release", but it bundles a few big changes.
LazyFrame.collect now defaults to the streaming engine, with large memory and speed gains on most queries.
Breaking: streaming doesn't guarantee row order for join, group_by and unpivot. Use maintain_order=True if order matters. This is why it's a major version.
Out-of-core (spill-to-disk) is on by default. It spills at about 80% of RAM ("may need tuning") with a 64 GB default disk budget. It covers sort, window functions and many expressions. Joins and group-bys are planned, not shipped.
The new native Map dtype (Arrow MapType) replaces the old List(Struct(key, value)) reading. It comes with map.get, map.contains_key, map.len, map.keys and map.values.
Stricter by design: errors should surface up front and implicit handling of data mismatches is opt-in. collect_schema() catches schema mismatches without reading data.
SQL is now a first-class interface, with join reordering, better common-subplan elimination, and dynamic predicates/bloom filters.
Benchmarks are self-run TPC-H/TPC-DS derived numbers against DuckDB 1.5.6 and 2.0 alpha, and DataFusion 54. They are not official TPC results.
Polars was fastest on all but one benchmark. At 192 threads its constant overhead hurts small data (SF10 TPC-DS is 1.8x slower), and a fix is hoped for in the next release.
Roadmap, not released: out-of-core joins and group-bys, better scaling at high core counts, Polars Cloud, and early GeoPolars work.
Upgrade guide: https://docs.pola.rs/releases/upgrade/2/
Michael #3: django-cachalot caches your ORM queries and invalidates them for you
django-cachalot is a Django package that caches ORM queries and invalidates them automatically when the underlying data changes. Install it, add one line to INSTALLED_APPS, and read queries run through your cache backend with no code changes. The trick is that it caches whole tables, so any write flushes that table's cached queries, making it a strong fit for read-heavy sites and a poor one for frequently updated tables. It supports Django 4.2 through 6.1 and Python 3.8 to 3.14.
ORM caching that normally takes careful engineering drops in with pip install and one settings line, invalidation included.
Near-100x on joins: the README reports nearly 100x speedups for initial deployments heavy on select_related and prefetch_related.
It caches the entire table, so a hot table with frequent writes invalidates constantly; docs suggest staying under 50 modifications per minute and mixing in cache-machine for hot paths.
Setup is two lines, plus caveats: sync clocks across servers sharing one cache, and run a manage.py command after restoring a database outside Django.
Calvin #4: Towards async transactions in Django
Carlton Gibson, The Stack Report, Oct 9, 2026. It's about getting async with transaction.atomic() into Django, hoped for 6.2 and not a commitment. Status check: both PRs are still open as of Oct 19-20, with no approvals and no milestone.
The problem: asyncio tasks share one thread and so one DB connection. A slow transaction that rolls back also discards a sibling task's quick write. Today transactions go through sync_to_async, so everything runs serially on one thread.
Design: async with transaction.atomic() opens a nested ThreadSensitiveContext, which gets its own worker thread and connection. On exit the connection is cleaned up and control returns to the request's connection. Siblings keep using the request's connection in autocommit, so their writes survive a rollback.
Only the task that opened the block may nest further atomic() blocks. Any other task raises TransactionManagementError, and this is enforced.
Subtasks inside a transaction are discouraged, since the connection is serial and parallel queries gain little. If you need them, use structured concurrency (TaskGroup or an awaited gather()) so they finish before the block exits. That rule is not enforced yet, and Gibson wants Django to catch late queries before 6.2.
Caveats: each async transaction uses an extra connection for its duration, so pools may need tuning. The advice to disable CONN_MAX_AGE for async still applies.
Origin: the Django on the Med sprint in Pescara (hosted by Paolo Melchiorre). An expert panel on Day 1 included Lily Acorn, Simon Charette, Jacob Walls, and Charlie Denton and Sam Searles-Bryant of Kraken Tech (authors of django-subatomic, which is being integrated into Django). Caleb Hattingh then investigated the design and opened both PRs.
PRs: Django #22074 ("Fixed #33882 -- async with transaction.atomic") has review comments from four people, with the latest commit on Oct 19 adding a test for a late child-task query. asgiref #596 (ThreadSensitiveContext changes) had Gibson's review on Oct 19 and follow-up edits on Oct 20.
Extras
Calvin:
Jazzband is Shutting Down (announced in March), but there are alternatives like https://django-commons.org/
Treemd — nice TUI for viewing Markdown https://github.com/Epistates/treemd
Michael:
Talk Python Membership
Talk Python Visual topic guides
Quick Follow Up to Episode #499 where we shared PEP 824 None coalescing operator, we also have PEP 823 (None Aware access operators) the successor to PEP 505. - via Nick Muoh and Rafael
Free Threaded Polars, but staled on PyPI?
Joke: LGTM (Looks Good to Me) - Claude Opus 5.5 music video
Más podcasts de Noticias
Podcasts a la moda de Noticias
Acerca de Python Bytes
Python Bytes is a weekly podcast hosted by Michael Kennedy and Calvin Hendryx-Parker. The show is a short discussion on the headlines and noteworthy news in the Python, developer, and data science space.
Sitio web del podcastEscucha Python Bytes, Un tema Al día y muchos más podcasts de todo el mundo con la aplicación de radio.es

Descarga la app gratuita: radio.es
- Añadir radios y podcasts a favoritos
- Transmisión por Wi-Fi y Bluetooth
- Carplay & Android Auto compatible
- Muchas otras funciones de la app









































