Aller au contenu
Python Bytes
PodcastActualitésActualités technologiquesAnglais

Python Bytes

par Michael Kennedy and Calvin Hendryx-Parker

Nouveau#504 Who turned the GIL back on?10 novembre 2026 · 30 min
Épisodes
504
Parution
hebdomadaire
Dernier épisode
10 Nov 2026
Site webFlux RSS

À propos du podcast

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.

Épisodes 504

  1. #504 Who turned the GIL back on?

    30 minÉpisode 504

    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 …

    Notes de l’épisode
    Topics covered in this episode:
    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

    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

  2. #503 It’s not 85% HTML

    30 minÉpisode 503

    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 …

    Notes de l’épisode
    Topics covered in this episode:
    Watch on YouTube

    About the show

    Sponsored by us! Support our work through:

    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:

    Joke: Binging red buttons

  3. #502 Introducing chameleon-rs

    34 minÉpisode 502

    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 …

    Notes de l’épisode
    Topics covered in this episode:
    Watch on YouTube

    About the show

    Connect with the hosts

    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

    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:

    Joke: captcha: too real!

  4. #501 A Nod to Sir-Mix-Alot

    38 minÉpisode 501

    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 …

    Notes de l’épisode
    Topics covered in this episode:
    Watch on YouTube

    About the show

    Sponsored by us! Support our work through:

    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

  5. #500 Episode 500!

    1 h 8 minÉpisode 500

    Topics covered in this episode: A quick chat with Brian looking back Extras Joke Watch on YouTube About the show Brian #1: A quick chat with Brian looking back Nick #2: Jev and the Case for Boring ML Vincent …

    Notes de l’épisode
    Topics covered in this episode:
    • A quick chat with Brian looking back
    • Extras
    • Joke
    Watch on YouTube

    About the show

    Brian #1: A quick chat with Brian looking back

    Nick #2: Jev and the Case for Boring ML

    Vincent Warmerdam from marimo benchmarked Jev, a new "System 1" decision model from TypeSafe AI. In his video It handles classification without the latency or token cost of generative LLMs, which raises a practical question for data teams: where does this fit alongside traditional machine learning?

    • He tested Jev against classical machine learning models to see if its speed and accuracy hold up on real-world datasets.
    • General LLMs work well for reasoning, but generating full token streams just to assign a category adds unnecessary latency and cloud cost.
    • Jev avoids generation entirely by evaluating the input and returning only the decision, which makes it much faster and cheaper than standard chat APIs.
    • It consistently outperformed eight-shot sentence transformer setups like SetFit out of the box, especially on datasets with dozens of target categories.
    • Traditional models like logistic regression still matter because they run in single-digit milliseconds on basic CPUs, cost nothing per inference, and keep private data within your own network.
    • You cannot fine-tune Jev directly, so standard models remain the better choice when your data contains internal company acronyms, product names, or domain slang.
    • The most practical approach is using Jev to bootstrap initial labels or audit bad training data, then training a small model you can own and run locally.

    Brett #3: Announcing the 2026 Python Packaging Council Election Results!

    The inaugural Python packaging council (PPC) has been elected and started meeting!

    • Introduced via PEP 772
    • 5 members elected
      • Top 2 vote-getters get two-year terms
      • Other 3 get one-year terms
      • All members will get two-year terms going forward, staggering the elections
    • There have been 4 meetings far as well as a meeting with the SC
    • As the inaugural packaging council still working out basic logistics like how to take notes
    • Also working out what the packaging council should do as PEP 772 explicitly says packaging.python.org falls under the PPC, but otherwise tries not to dictate what the PPC is in charge of

    Calvin #4: Parsing JSON at tens of gigabytes per second in Python

    • Daniel Lemire (Oct 12) benchmarks fastsimdjson 0.6.0, a Python binding for simdjson on PyPI, repo at simdjson/fastpysimdjson. Its map_many function runs a callback per JSON line across N threads.
    • Workload: Eight hours of GH Archive data, 7.6 GB and 2.2M events. The task counts event types and looks up the target repo's language for each opened PR, and it only touches a few fields per event.
    • Lazy trick: With lazy=True, the whole event is parsed but Python objects are created only for the fields you access. The idea comes from Tyler Kennedy's pysimdjson.
    • Single core: stdlib json gets 0.18 GB/s (about 42 s for the whole set), orjson 0.42, msgspec 1.29, fastsimdjson lazy 2.13 (3.6 s).
    • 64 cores: stdlib json gets 3.17 GB/s, msgspec 24.6, fastsimdjson eager 29.8, and fastsimdjson lazy 65.7. That's the full 7.6 GB in about 0.12 s, roughly 31x its own single-core speed.
    • Requires free-threading: It ran on Python 3.14.6 free-threaded (3.14t) on a 64-core dual-Xeon box.
    • Grain of salt:
      • It's one machine and one dataset.
      • It's an embarrassingly parallel job with per-thread counters.
      • The lazy win only shows up when you read a few fields from big objects.
      • msgspec was handed a schema declaring only the needed fields.
      • The post itself doesn't say whether this generalizes.

    Michael #5: Grinberg's annual benchmark says 3.15 is flat, but the JIT finally pays off

    Miguel Grinberg ran his annual release-eve benchmark, comparing Python 3.15.0rc3 against every interpreter back to 3.10, plus PyPy, Node.js, and Rust, using his usual two CPU-bound programs: recursive Fibonacci and bubble sort. The standard 3.15 interpreter lands within noise of 3.14 on his workloads, while the experimental JIT build is roughly 20 to 28 percent faster and finally beats the standard interpreter, which has not happened before. The free-threaded build holds up well in the 4-thread tests. He is candid that the workloads are just Fibonacci and bubble sort, and the official release lands days after his measurements.

    • It is an independent, workload-based counterpoint to the official 7-8 percent JIT geometric-mean claim, from a series with real trend data back to 3.10.
    • He did the same exercise for 3.12, 3.13, and 3.14, so there is a multi-year trend line to draw on.
    • Methodology is two hand-picked CPU-bound programs, recursive Fibonacci plus bubble sort, not a pyperformance-style suite, which cuts both ways.
    • PyPy 3.12 still runs circles around every CPython in the single-threaded tests, and Rust is about 77x faster on Fibonacci.
    • The JIT gain is real in these numbers, but the JIT stays experimental, so he will not use it in production yet.
    • Free-threaded fibo at 4 threads ran about 4.5x faster than the standard interpreter with the GIL.
    • His verdict: not worth rushing an upgrade for speed alone, though lazy imports may tempt production projects.

    Carol #6: Transparent and trusted AI Our Way - Satyrn AI

    Paul Everitt, Georgi Ker and I were discussing Python, its community and AI back in March at the JetBrains PyTV event. Python is the foundational language for data science and AI tools. We wanted something that reflects the Python community's strengths: language and learning.

    • Mission: https://satyrn.ai/mission/
    • Python 3.15 trained model is on Hugging Face
    • After Paul's Europython keynote, he asked for folks to join the community (think of it as a collective of individuals putting their talents together
    • We used some of the organizational tips from Jupyter and JupyterHub's early days on scaling community and emphasizing leveling up individuals
    • Paul will be keynoting in Africa and sharing progress made by a team of dedicated volunteers
    • Putting AI tools and knowledge in the hands of Pythonistas makes good sense and over time will benefit people (A theme that I have spoken about since PyCon 2023 and most recently PyCon JP 2026

    Extras

    Michael:

    • Adobe Creative Suite was mostly cloned in Rust
      • ArtCraft released seven free, open-source desktop apps that mirror the Adobe lineup: PhotoCraft for Photoshop, VectorCraft, FilmCraft, LightCraft, PrintCraft, EffectCraft, and DesignCraft. Everything is written from scratch in Rust with WebAssembly builds for the browser, and developer Brandon Thomas says the apps are AI-built clean-room reimplementations, a claim Ars Technica covered alongside the predictable skepticism.
        • The clean-room story matters: reimplementing Adobe from public specs and behavior with AI is legally defensible, and building the apps for agents to drive, not just humans, is a genuinely different design bet.
        • PhotoCraft already shows real depth: layers, masks, adjustment layers, layer styles, and real PSD support, with over 1,700 tests and dual CPU and GPU compositors tested against each other.
        • The agent story: an MCP server and JSON control protocol let an agent headless-edit documents or drive the live app, useful for bulk edits and first drafts.
        • Tradeoffs are real: reviewers call most of the apps super early alpha, and trade dress claims from Adobe remain a live legal risk even for clean-room code.
        • Sustainability matters: the founder says token sales from their ArtCraft AI model fund the work so it does not become an orphaned small-team project.
        • What happens when open-source alternatives that once took years of community work can be built by a model in weeks?
      • Reminds me of the chardet story we covered awhile ago. The reason I put this topic here is I think it encapsulates a lot of what's happening in the industry for devs now. Building software has changed, creating is easy - sustaining is hard, owning an idea is more fleeting than before, Rust obviously, MCP and CLIs. It's just an interesting bridge from the first 500 episodes and the next 500 likely.

    Calvin:

    Nick:

    Brett:

    Joke:

    • Exceptional by Derrick Chambers
      • Interviewer: It says here on your résumé that you’re an “exceptional Python developer.” Can you prove it?
      • Me: Sure. Run any of my code. It raises exceptions a lot of the time.

  6. #499 So many questions??

    33 minÉpisode 499

    Topics covered in this episode: PEP 824 brings ?? and ??= to Python for None handling Python 3.15 gets a surprise RC3, and Python 3.10 reaches end of life asyncio.shield Pyxel: the retro game engine for Python …

    Notes de l’épisode
    Topics covered in this episode:
    Watch on YouTube

    About the show

    Sponsored by us! Support our work through:

    Connect with the hosts

    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: PEP 824 brings ?? and ??= to Python for None handling

    PEP 824, a new draft from Marc Mueller sponsored by Guido van Rossum, proposes None-coalescing operators for Python 3.16. The ?? operator returns its left-hand side unless that value is None, and ??= assigns a fallback only when the target is None. It revives the long-deferred PEP 505 from over a decade ago, trimmed to just these two operators, with None-aware access split off into PEP 823. The goal is replacing verbose is None checks with something closer to or, but keyed on None instead of truthiness.

    • Every Python codebase has piles of if x is None fallback code, and this is the first serious move in ten years to give it real syntax.
    • user.age ?? "unknown" is like or but only falls back on None, so 0, "", and [] pass through instead of getting clobbered
    • user.name ??= "unknown" replaces the two-line check-then-assign pattern, with left-side subexpressions evaluated and cached exactly once
    • Precedence sits between or and conditional expressions, matching JavaScript and C#, and ?? lands as a BoolOp in the AST next to and and or
    • Unlike +=, ??= is a conditional assignment that skips the right side entirely, which is why it gets its own AST node rather than AugAssign
    • Still draft status targeting 3.16, with a working reference implementation and an online demo to try, and it notably rejects a soft keyword like otherwise in favor of the familiar ??
    • Discussion-worthy: the PEP answers the old objection that making None easier will proliferate its use, pointing out None is already everywhere and the status quo just produces uglier code
    # OG way user = db.get_user() city = None if user is not None: if user.address is not None: if user.address.city is not None: city = user.address.city # Michael's preferred way user = db.get_user() city = user?.address?.city

    Calvin #2: Python 3.15 gets a surprise RC3, and Python 3.10 reaches end of life

    • The release team added a surprise third release candidate for Python 3.15 to fix last-minute lazy-import release blockers. They wanted time to test the fixes properly.
    • That pushes the 3.15.0 final release from October 2 to October 9, 2026.
    • RC3 has about 156 fixes from 82 contributors. The headline features are explicit lazy imports (PEP 810), the new frozendict (PEP 814) and sentinel (PEP 661) built-ins, and UTF-8 as the default encoding (PEP 686).
    • No more ABI changes are coming, so library authors should be building 3.15 wheels now. uv 0.12.23 already added CPython 3.15.0rc3.
    • On October 1, Python 3.10.22, 3.11.17, 3.12.15, 3.13.16 and 3.14.8 shipped together with nine common security fixes. They cover SSL validation, tarfile and zipfile handling, and urllib credentials.
    • Python 3.10.22 is the final 3.10 release. After five years it gets no more security updates, so anyone still on 3.10 should upgrade.
    • Python 3.13.16 is the last full maintenance release of 3.13, which now moves to security-only fixes. Only 3.13.16 and 3.14.8 have Windows and macOS installers, and the older releases are source-only.
    • Python 3.11 gets security fixes through October 2027, and 3.12 through October 2028.
    • A natural way to tie the two together: one version is nearly out the door and one is officially gone, and the same week is the time to test your code on 3.15 and move off 3.10.

    Michael #3: asyncio.shield

    Where async code can be cancelled

    In async Python, every await is a point where your coroutine can be stopped. If someone cancels the task, asyncio raises CancelledError at whichever await the coroutine is paused on, and nothing after that line runs. Quart does this on purpose. When the client disconnects, it cancels the request's task. From quart/asgi.py:

    elif message["type"] == "http.disconnect": self._disconnected = True request.body.disconnect() request_task.cancel()

    That's reasonable for a slow page nobody is waiting on anymore. It's a problem for a handler that writes to the database in two steps:

    await downloads.insert_one(event) # 1. log the download await totals.update_one(..., {'$inc': ...}) # 2. bump the episode's total

    A podcast app requests the MP3, gets what it needs, and hangs up. If it hangs up while step 2 is in flight, step 1 has already landed and step 2 never runs. Nothing is logged and nothing reaches Sentry, because a cancelled request isn't an error. The two collections just drift apart. Under WSGI this couldn't happen. A disconnect didn't stop your view; the view finished both writes and the server only failed later, when it tried to send the response.

    The demo

    I ran this on Python 3.14. The "client" hangs up 15 ms into a pair of 10 ms writes:

    async def record_download(): await db_write('events') await db_write('total') _pending: set[asyncio.Task] = set() async def record_download_shielded(): task = asyncio.create_task(record_download()) _pending.add(task) task.add_done_callback(_pending.discard) await asyncio.shield(task) record_download events=1 total=0 record_download_shielded events=1 total=1

    The unshielded version loses the increment. The shielded version finishes it, even though the request was cancelled. The full script is in the scratchpad as shield_demo.py if you want it for the show.

    What asyncio.shield does, and its traps

    shield(task) protects the inner task from a cancellation aimed at the outer one. The handler still gets CancelledError immediately, so nothing after that line runs, but the inner task keeps going until both writes finish. The traps:

    1. Keep a reference to the task. The event loop only holds weak references to tasks, so a task with no other reference can be garbage-collected mid-run. The asyncio docs warn about this. That's what _pending is for.
    2. Its errors go nowhere by default. If a shielded write fails after the handler has already been cancelled, nobody awaits the result. You only get a "Task exception was never retrieved" warning. Log errors from inside the task, or in the done callback.
    3. It doesn't survive a process shutdown. If the event loop is closing, as during a Granian worker recycle or a deploy, pending tasks are still cancelled. The window is tiny, but it isn't zero.
    4. It hides hangs. A shielded write to a stuck database lives forever. Put a timeout inside the shielded task (asyncio.timeout(...)), not outside it.
    5. It makes the pair finish, not atomic. A crash between the two writes still splits them. The real fix is one operation that can't half-happen. That's what the SQLite move gets: an insert and an upsert in one synchronous transaction, with no await in the middle. Shield is the right patch for the Mongo code until then. The general lesson: in async code, related writes made one after another are only as reliable as the client's patience. Before shipping something like that, check whether your framework cancels on disconnect. Quart does, and I believe Django 5's async views do too. I don't think Starlette cancels a plain endpoint, but I haven't checked any of these other frameworks' source, so verify them before you say it on air.

    Calvin #4: Pyxel: the retro game engine for Python

    • Pyxel is a free, MIT-licensed retro game engine for Python, built and maintained by a single developer. It has been in development since 2018 and has passed 18,000 GitHub stars.
    • It's modeled on classic game consoles and deliberately limits you to 16 colors and 4 sound channels, which keeps scope small and games finishable.
    • Built-in editors cover pixel art, tilemaps, sound and music, so you can make the graphics, audio and game logic in one place.
    • The engine is implemented in Rust and compiled to WebAssembly, but you write your games in plain Python.
    • Pyxel Code Maker is a browser playground with a code editor, resource tools and a run button. It loads projects from local files, GitHub Gists or URLs, and saves back to a Gist for sharing.
    • Games can also run on the web, so sharing one can be as simple as sending a link.
    • It's a fun, low-barrier way into game development, good for beginners and for teaching kids.

    Extras

    Calvin:

    Joke: I was there.

  7. #498 A Tiny Episode

    33 minÉpisode 498

    Topics covered in this episode: MemTensor / MemoryOS PyPI package hijacked via a malicious build backend TinyMongo Jev: what to know One innocent dict read makes attribute access permanently slower Extras Joke …

    Notes de l’épisode
    Topics covered in this episode:
    Watch on YouTube

    About the show

    Sponsored by us! Support our work through:

    Connect with the hosts

    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: MemTensor / MemoryOS PyPI package hijacked via a malicious build backend

    • On Sept 23 an attacker published backdoored MemoryOS 2.0.34 on PyPI and three bad versions (0.1.21, 0.1.23, 0.1.25) of MemTensor's OpenClaw plugin on npm. PyPI had no clean release that day, so 2.0.34 was the newest.
    • They pushed commits to MemTensor's own GitHub Actions release pipelines. On PyPI that was a custom Poetry build backend, and on npm a tweaked validation script. Both used BASH_ENV to hand the publish token to the attacker before the real publish ran. SafeDep couldn't confirm how the attacker got push access.
    • Runs on import, not install: A Go implant called sckit starts when the library loads, so --ignore-scripts won't save you.
    • It harvests credentials from your home directory (npm and PyPI tokens, GitHub tokens, SSH keys, cloud CLI tokens, .env files) and sends them to skyleen[.]fr servers.
    • It's a worm: It uses stolen tokens to copy itself into other repos and packages, so the victim list could grow.
    • If you installed it: Downgrade to MemoryOS 2.0.33 (plugin 0.1.20) and rotate every credential reachable from $HOME. Also kill any running sckit stage0 process and check repos you can push to for a stray runtime-update.yml workflow or .sckit/ directory.

    Michael #2: TinyMongo

    • Want to use a MongoDB data interface, but swap out the storage engine?
      • Memory for testing/caching
      • JSON/TinyDB simple JSON files
      • SQLite for durable, high-perf reads with WAL
      • SQLIte shared for high write apps
      • DuckDB + Parquet for analytics apps
      • Postgres + MariaDB for multi-machine client/server
    • Great for teaching, examples, and simple deployments
    • Amazing story of paired AI development
      • Will completely run talkpython.fm after weeks of shared work together (in SQLite mode).

    Calvin #3: Jev: what to know

    • What it is: Jev is a model from TypeSafe AI that answers with typed results (yes/no probabilities, scores, picks from your options) instead of prose. Real Python published a hands-on tutorial on 2026-09-24 and the buzz on hacker news is almost deafening.
    • It's proprietary: Jev is a hosted, closed-weight model. There are no weights to download and no self-hosting. Everything called "open Jev" is an independent reimplementation, not TypeSafe's model.
    • Your data leaves your machine: Every call sends your input text to a third-party API. In the tutorial that path goes through OpenRouter to TypeSafe. Think twice before sending customer messages, tickets or anything sensitive.
    • Cost and stability are open questions: The tutorial calls Jev "cheap, but not free" and says it's fast and cheap "at the moment." It also says whether that stays true is "something to keep an eye on."
    • Credit to Real Python: It's a good, practical intro. It shows the Noul, Score and Choice primitives, and its point that instruction wording matters more than thresholds is useful advice for any model. The tutorial itself says similar results are possible with a well-prompted LLM.
    • Open options to look at instead:
      • JevK5 (https://github.com/allebee/jevk5): Apache-2.0 weights and code, 4B or 9B parameters, and it accepts TypeSafe-style requests.
      • SemIf, formerly OpenJev (https://github.com/TheoLeeCJ/openjev): MIT-licensed, small models, and it can run CPU-only.
      • openjev-sglang (https://github.com/ekzhang/openjev-sglang): a Jev-compatible endpoint running Qwen3.6-35B-A3B, but no license is stated, so check before commercial use.
    • The catch: These copy Jev's interface, not its model or training. Results will differ, and I haven't run any of them. Benchmarks are self-reported, and JevK5 is English-only.

    Michael #4: One innocent dict read makes attribute access permanently slower

    Timofei Ivankov benchmarks a CPython internals surprise: since 3.11, attribute access skips the instance dict entirely. A specialized opcode reads the attri.bute at a fixed byte offset in the object's inline values array. Read obj.__dict__ once, though, and the dict gets materialized, the object loses that specialized path for the rest of its life, and a million-iteration loop goes from 33 ms to 51 ms on CPython 3.14. vars() and copy.copy() trigger the same thing, so a debugging print or a shallow copy in code touching your hot objects quietly makes every later attribute access roughly 1.5x slower.

    • The slowdown is permanent and nothing about it looks like a performance decision: ordinary code far from the hot loop can trigger it, and the function that gets slower never changes.
    • Materializing dict produces a split table, and the LOAD_ATTR_WITH_HINT fallback declines split tables, so the object ends up with no specialization at all
    • vars(), 'x' in o.dict, and copy.copy() all materialize it; copy.copy is the realistic trap since nobody treats a shallow copy as a performance decision
    • slots instances read attributes at exactly the same speed and cannot fall into the trap since there is no dict to materialize
    • On the free-threaded build both effects grow: atomic incref on reads plus an object lock on writes push the penalty from 17.6 to 25.4 ns
    • Credit: this item was surfaced by the PyCoder's Weekly newsletter

    Extras

    Calvin:

    • whatsnewt - a TUI text adventure through what's new in Python 3.15; playful but niche.

    Joke: Shipping a button in 2026…

  8. #497 Faster than light profiling

    27 minÉpisode 497

    Topics covered in this episode: Tachyon: A sampling profiler ships in Python 3.15's stdlib Python Workers are now generally available on Cloudflare Flet 1.0 - build cross-platform apps in Python marimo-book …

    Notes de l’épisode
    Topics covered in this episode:
    Watch on YouTube

    Sponsored by Logfire from Pydantic: pythonbytes.fm/logfire Connect with the hosts

    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: Tachyon: A sampling profiler ships in Python 3.15's stdlib

    • Python 3.15 adds the profiling package per PEP 799: profiling.tracing (where cProfile moved) and profiling.sampling, the new sampler called Tachyon
    • py-spy and Austin exist but copy raw interpreter bytes with no API, so every CPython release risks breaking them; one in the stdlib is a contract to stop breaking profilers
    • Defaults: 1 kHz, main thread, wall clock, and a -live top-like view for poking at a slow server
    • Output is flexible: pstats, -flamegraph, -diff-flamegraph against a baseline, -heatmap on source lines, -opcodes for specialized bytecode, -gecko for Firefox Profiler with GIL and GC markers
    • Profiling modes: wall, cpu, gil (which function is starving my other threads?), and exception, plus -async-aware to see the task graph instead of just select(), -all-threads, and -subprocesses forking a profiler per child
    • Near-zero overhead for production; guidance is 10-30 second windows on representative load, and free-threaded builds divide the rate by thread count
    • Attach to a running PID, same minor version only; ptrace permissions are the main friction. A 3.14 backport already exists on GitHub
    • Caveat: it only sees Python frames, so 90% in calculate() hides NumPy underneath. For native stacks there's Cronon from HRT, 200k samples/sec over DWARF, not yet open source

    Calvin #2: Python Workers are now generally available on Cloudflare

    • Python Workers are out of beta - now GA, "first-class" language on Cloudflare's Developer Platform
    • No more manual JS interop: bindings (queues, R2, D1, Durable Objects) now work natively in Python, e.g. self.env.QUEUE.send({...})
    • Runs on Pyodide (WASM-compiled Python), with real TCP socket support for DB connectivity
    • Frameworks supported: FastAPI, Django, Flask; AI libs like OpenAI SDK, LangChain, MCP
    • Underlying platform work formalized as PEP 783 (PyEmscripten), after a year of discussion
    • Bottom line: write real Python on Cloudflare's edge, no JS glue code required

    Calvin #3: Flet 1.0 - build cross-platform apps in Python

    • Flet hits 1.0 - build Flutter-backed apps from pure Python, no frontend experience needed
    • One codebase targets six platforms: iOS, Android, Windows, macOS, Linux, web
    • 150+ built-in UI controls, plus support for custom controls / wrapping Flutter packages
    • Mobile now supports real Python packages: NumPy, pandas, Pillow, cryptography
    • Comes with pytest-based UI testing and an MCP integration for AI coding assistants
    • Milestone lands 4+ years after its first PyPI release (Sept 2022) - signals "production ready," not experimental

    Michael #4: marimo-book: Build static books from marimo notebooks

    marimo-book is a Jupyter-Book-style static site generator built specifically for marimo .py notebooks. It ships polished multi-page sites with Material for MkDocs theming, full-text search, dark mode, and code copy, plus a content-hashed incremental build cache that drops rebuilds from 100+ seconds to roughly 3 seconds on real books. Standout extras include anywidget rendering without a kernel, static reactivity for discrete sliders via pre-rendered lookup tables, an opt-in WASM/Pyodide mode per chapter, and per-chapter launch buttons.

    • If you've wanted to publish a marimo notebook as a real book or course site without hosting a kernel, marimo-book gives you the static, searchable, fast-loading output you'd expect from Jupyter Book.
    • Alpha (0.1.x), but in production: pin marimo-book>=0.1.5,<0.2; the book.yml schema is stable for v0.1, and dartbrains.org is a real-world user.
    • Two-stage build by design: a marimo-aware preprocessor emits plain Markdown + inline HTML, then mkdocs (Material today, zensical tomorrow) renders it. Not a mkdocs plugin, so the shell stays swappable.
    • Interactive widgets without a kernel: anywidget Canvas/Three.js/Plotly mounts render statically, and mo.ui.slider with explicit steps gets pre-computed as a static lookup table.
    • WASM escape hatch per chapter: set mode: wasm and the chapter routes through marimo's MarimoIslandGenerator, shipping the marimo runtime + Pyodide bundle for full reactivity where you need it.
    • Per-chapter launch buttons and extras: readers can jump to molab, GitHub, or a downloaded .py; optional [social], [linkcheck], and [pdf] extras cover OG cards, htmlproofer, and WeasyPrint PDF export.
    • Sandboxed notebooks: the sandbox mode reads PEP 723 inline metadata and provisions per-notebook envs via uv for portable builds, at the cost of slower first runs.

    Extras

    Calvin:

    • Great overview of a new feature in Python 3.15 - frozendict

    Michael:

    Joke: You have homework (no really ;) )

    Watch Interview with Big Data engineer in 2026 by Kai Lentit

  9. #496 A lake house in Seattle

    33 minÉpisode 496

    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 …

    Notes de l’épisode
    Topics covered in this episode:
    Watch on YouTube

    Sponsored by Logfire from Pydantic: pythonbytes.fm/logfire

    Connect with the hosts

    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:

    Joke: We’re agentic now

  10. #495 Banned

    28 minÉpisode 495

    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! …

    Notes de l’épisode
    Topics covered in this episode:
    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 [email protected] 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:

    Michael:

    • Steering council voting is now open

    Joke: Makes you look like this?

  11. #494 Python Wrapture

    29 minÉpisode 494

    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 …

    Notes de l’épisode
    Topics covered in this episode:
    Watch on YouTube

    About the show

    Sponsored by us!

    Support our work through:

    Connect with the hosts

    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:

    Michael:

    Joke: Tao of Programming: Book 5 Maintenance

  12. #493 CalVer and LTS

    41 minÉpisode 493

    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 See …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/493

  13. #492 Codeberg Puts Head in Sand

    39 minÉpisode 492

    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 …

    Notes de l’épisode
    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
    See the full show notes for this episode on the website at pythonbytes.fm/492

  14. #491 Feeling Judged

    42 minÉpisode 491

    Topics covered in this episode: Claude Code /insights Post-quantum crypto lands in Python MCP goes stateless — and FastMCP gets renamed inshellisense - IDE style command line auto complete Extras Joke See the …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/491

  15. #490 It’s a vibe coding party

    37 minÉpisode 490

    Topics covered in this episode: Some more things about Django I've been enjoying Who cleans up after the vibe-coding party? Where Did All Your AI Tokens Go? AgentsView to the rescue! Careful with phishing all …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/490

  16. #489 Or JSON?

    31 minÉpisode 489

    Topics covered in this episode: django-orjson Best Django Redis configuration for speed and size Linus Torvalds puts the foot down against Anti-AI Kernel Maintainers Django Steering Council backs the Triptych …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/489

  17. #488 tau - it's 2pi and it writes code

    32 minÉpisode 488

    Topics covered in this episode: The trusted-publishing debate: how to do it right vs. why you shouldn't trust it JupyterLab 4.6 and Notebook 7.6 are out! Tau – new small, readable terminal coding agent Django …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/488

  18. #487 Minimum requirements

    28 minÉpisode 487

    Topics covered in this episode: dust - a better du Hermes Agent: The AI agent that grows with you llm-coding-agent 0.1a0 Extras Joke See the full show notes for this episode on the website at pythonbytes.fm/487

  19. #486 underscore-underscore-ghost-emoji

    30 minÉpisode 486

    Topics covered in this episode: Free-threaded Python: past, present, and future django-admin-site-search Qwen 3.6 27B is the sweet spot for local development A large batch of PEPs are finalized Extras Joke See …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/486

  20. #485 Creating memories

    38 minÉpisode 485

    Topics covered in this episode: Backup Docker volumes locally or to any S3 Pyodide 314.0 Release nb-cli: A Command-Line Interface for AI Agents and Notebook Automation Hindsight Agent Memory That Learns Extras …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/485

  21. #484 All our tools

    50 minÉpisode 484

    Topics covered in this episode: pi + superpowers Terminal: Warp.dev + OhMyZSH {Blink,kitty} + mosh + tmux Claude code MacWhisper or Handy Tailscale Extras Joke See the full show notes for this episode on the …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/484

  22. #483 Thanks Brian

    29 minÉpisode 483

    Topics covered in this episode: Vulnerability and malware checks in uv HTTP GET requests with the Python standard library Millions of AI agents imperiled by critical vulnerability in open source package …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/483

  23. #482 Mr. Beast's episode

    24 minÉpisode 482

    Topics covered in this episode: CVE-2026-48710: A Maintainer's Perspective daily-stars-explorer Markdown to pdf with pandoc and typst postman2pytest Extras Joke See the full show notes for this episode on the …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/482

  24. #481 Ways to die

    33 minÉpisode 481

    Topics covered in this episode: Dumb Ways for an Open Source Project to Die How to create a pylock.toml lockfile https://github.com/facebook/Lifeguard Choosing a Python Logging Library in 2026 Extras Joke See …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/481

  25. #480 Proud Parents

    33 minÉpisode 480

    Topics covered in this episode: Using Django Tasks in production Co-authored with Claude? PyPI packages are increasing rapidly httpx2 Extras Joke See the full show notes for this episode on the website at …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/480

  26. #479 Talking About Types

    36 minÉpisode 479

    Topics covered in this episode: httpxyz one month in Learn concurrency - a deep dive into multithreading with Python pip 26.1 - lockfiles and dependency cooldowns Python 3.15 sentinal values from PEP 661 Extras …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/479

  27. #478 Iodine tablets and potable water

    40 minÉpisode 478

    Topics covered in this episode: profiling-explorer Reverting the incremental GC in Python 3.14 and 3.15 VSCode AI Co-author defaults to on, then off django freeze Extras Joke See the full show notes for this …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/478

  28. #477 Lazy, Frozen, and 31% Lighter

    46 minÉpisode 477

    Topics covered in this episode: Django Modern Rest Already playing with Python 3.15 Cutting Python Web App Memory Over 31% tryke - A Rust-based Ptyhon test runner with a Jest-style API Extras Joke See the full …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/477

  29. #476 Common themes

    32 minÉpisode 476

    Topics covered in this episode: Migrating from mypy to ty: Lessons from FastAPI Oxyde ORM Typeshedded CPython docs Raw+DC Database Pattern: A Retrospective Extras Joke See the full show notes for this episode …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/476

  30. #475 Haunted warehouses

    41 minÉpisode 475

    Topics covered in this episode: Lock the Ghost Fence for Sandboxing MALUS: Liberate Open Source Harden your GitHub Actions Workflows with zizmor, dependency pinning, and dependency cooldowns Extras Joke See the …

    Notes de l’épisode
    Topics covered in this episode:
    See the full show notes for this episode on the website at pythonbytes.fm/475

Voici les 40 derniers épisodes sur 504. Les épisodes plus anciens se trouvent dans le flux du podcast.

Podcasts similaires

Plus de podcasts : Actualités
C’est votre podcast ?

Confirmez-le avec une entrée dans votre flux : vous recevez ici un code, vous l’ajoutez comme podcast:txt dans le canal de votre flux, et nous le vérifions. Votre podcast apparaît ensuite comme « vérifié » sur SoundNode.

Genres populaires

PopOldiesHip-hopRockAnnées 80SchlagerActualitésAlternatifDanceMetalTechnoLes années 90ÉlectroHouse

Paramètres

Affichage

Langue

DeutschEnglishEspañolFrançaisPortuguês

Détermine les stations affichées en premier sur la page d’accueil.

Historique

Les stations et épisodes écoutés récemment et tes dernières recherches sont seulement enregistrés dans ce navigateur.

Notifications

Un court message quand un podcast que tu suis publie un nouvel épisode. Désactive un podcast précis avec la cloche sur sa page.

Compte

Enregistrez vos favoris – dans l’app et sur le site.

App StoreGoogle PlayAmazon Fire TVSonos

Raccourcis clavier

/
Ouvrir la recherche
Espace
Lecture ou pause
← →
Dans le lecteur : 15 s en arrière, 30 s en avant (épisodes) · dans une rangée : tuile suivante
↑ ↓
Dans une rangée : cible dans la tuile
Début / Fin
Dans une rangée : première ou dernière tuile
Esc
Fermer la fenêtre ou le menu
?
Cet aperçu
En cours de lecture

Voir la station

À suivre

    Ajoutez des épisodes avec « À suivre » – ils seront lus après l'épisode en cours.