BlueberryPy

This Month for Pythonistas - September 2026

Zeyang Lin — Wed, 30 Sep 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 9

Welcome back Pythonistas! This is the September 2026 issue of “This Month for Pythonistas”, curating Python news, tutorials, articles, podcasts, repositories and community highlights for this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

RISC-V is now officially supported by CPython!

CPython now officially supports RISC‑V as a tier‑3 platform, thanks to months of community work and RISE project hardware. Contributors fixed architecture‑specific issues, improved builds, and added testing on real hardware. Ongoing CI integration and potential tier‑2 promotion are planned, plus architecture‑specific optimizations. Users with RISC‑V hardware are encouraged to build CPython, run workloads, and report issues to help improve support.

GPT-6.1 Sol

OpenAI introduced GPT‑6.1 Sol, an upgraded version of GPT‑6 Sol tuned for agentic coding, computer use and professional work, delivering performance close to flagship GPT‑6 Astra at roughly one‑fifth the price ($2/$10 per million input/output tokens, $0.10 cached). It gains +6.4 points on DeepSWE, beats Opus 5.5 on GDP.pdf and AutomationBench at far lower cost, improves OSWorld 2.0 by 7 points, more than doubles Terminal‑Bench Science scores, and lowers factual‑error rate to 4.1%, with stronger alignment.

Introducing Claude Opus 5.5

Anthropic introduces Claude Opus 5.5, the first model in its Claude 5.5 family — a new flagship roughly matching Claude Fable 5.1 while costing ~40% less than Opus 5 ($4/$20 per million tokens, $0.20 cache reads) and producing output 30%+ faster. It leads in agentic coding, computer use, knowledge work, and science benchmarks, with testers citing dramatic efficiency gains on long jobs like codebase migrations. It scores best-ever on Anthropic’s behavioral audit, resists prompt injection better, keeps biology/cyber safeguards via verification programs, and writes more clearly.

Introducing Claude Sonnet 5.5

Claude Sonnet 5.5 is the second model in the Claude 5.5 family: a faster, cheaper complement to Opus 5.5, best for well-scoped everyday tasks, bug fixes, and polished documents, slides, and spreadsheets. It runs 30%+ faster and costs up to 30% less per task than Sonnet 5 at unchanged pricing. Gains are dramatic — 70.6% versus 10.3% on Terminal-Bench 4.0, near-Opus results on GDPval-AA, OSWorld, and chart recognition, and it’s the first Sonnet to beat Pokémon Red from screenshots alone.

New Versions

Python 3.15.0 candidate 2 is here!

This release, 3.15.0rc2, is the final planned release candidate, containing around 144 bugfixes, build improvements and documentation changes from 76 contributors since 3.15.0rc1. The next release of Python 3.15 will be 3.15.0 final, scheduled for 2026-10-01.

PyTorch 2.14 Release Blog

PyTorch 2.14 is released, built from 2,995 commits by 487 contributors since 2.13. Highlights include NVGEMM (CuTeDSL-based CUTLASS GEMM kernels in Inductor with epilogue fusion and NVFP4 support), a preview of the rewritten “nccl2” NCCL backend from torchcomms, first-class fault tolerance in c10d with in-place process-group reconfiguration, one-sided RMA windows, and a backend-agnostic Flight Recorder. Apple Silicon gains native linear algebra (SVD, QR, Cholesky) plus more Metal kernels. New compiler features include torch.switch, graph-captured while_loop, declarative @dynamic_spec shapes, experimental complex-tensor compilation, Python 3.15/free-threaded wheels, and expanded ROCm 7.14, Intel XPU, and NVIDIA Rubin support.

PyPy v8.0.0 release

PyPy v8.0.0 is a major version shipping three interpreters: PyPy2.7, PyPy3.11 (likely the last 3.11 release), and a first-ever “beta”-quality PyPy3.12. The major bump reflects Linux builds moving to manylinux_2_28 (AlmaLinux 8, glibc 2.28, gcc14). Python 3.12 adds cp312-abi3 support by hiding PyPy’s internal ob_pypy_link field, so CPython limited-ABI wheels should work — though import machinery and pip/uv acceptance remain unfinished. RPython code generation improved via computed gotos, inlining, and source-mapping comments. The internal HPy backend was dropped, and the clang-based pyhdrdump tool was revived.

Tutorials

deeplearning.ai’s Building Adaptive AI Agents by Oracle

In this course, you’ll work with three adaptation layers. For behavior adaptation, you’ll build a skill induction pipeline that turns the agent’s traces, its conversations, tool calls, errors, and fixes, into reusable skills it applies the next time it sees a similar task, with a human in the loop approving each skill. For knowledge adaptation, you’ll build a code knowledge graph that connects files through imports, function calls, and co-edits in git history, so the agent retrieves context by navigating the structure of the codebase instead of relying on keyword search. For model adaptation, you’ll learn when it makes sense to adapt the model itself with techniques like fine-tuning.

deeplearning.ai’s Building AI Assistants with On-Device Memory by Qdrant

A cloud-based assistant can remember what it sees, hears, and is told, but only by staying connected and sending that data to a remote server. An assistant that runs on the device builds that memory locally instead. Every note, photo, or recording becomes a vector you can search by meaning, tag with context, and delete on command, all without leaving the device.

RealPython’s How to Write an AGENTS.md File for a Python Project

An AGENTS.md file gives your AI coding agent the context it needs to write code that fits your project’s guidelines. It’s a plain Markdown file at your project root where you can pin your Python version, dependency manager, coding conventions, and constraints. In this tutorial, you’ll build one of these files section by section and watch your agent go from sloppy output to clean, idiomatic code.

RealPython’s How to Review AI-Generated Python Code Efficiently

An AI coding agent writes code faster than any human can read it, which makes you the bottleneck. Your job and responsibilities stay the same, but the volume and speed increase. To manage this, you need to review the code with a plan. You can’t read every line, so focus on the parts where the risk is highest.

Articles

Speeding Up a Python Service with CinderX: JIT and Static Typing

This article examines CinderX, a CPython extension adding a full JIT compiler, “Static Python” typed subset, parallel garbage collector, and heap immortalization. Unlike CPython 3.14’s cheaper copy-and-patch tier 2, CinderX compiles entire functions through typed HIR/LIR SSA passes into machine code. Benchmarking a real recommendation service shows only typed kernels plus JIT meaningfully helped: throughput rose from 140 to 250 requests/second, p99 fell from 279ms to 13ms. Flags alone changed nothing; NumPy-bound endpoints gained zero. Types without JIT cost 3.4× more.

Soft-deprecating re.match()

This post from Hugo van Kemenade explains Python 3.15’s soft deprecation of re.match(), whose start-anchored-but-not-end-anchored behavior surprises many developers. Soft deprecation, introduced by PEP 387, is a documentation-only recommendation: no warnings, no removal, and it doesn’t graduate into hard deprecation. The release adds re.prefixmatch(), an explicit alias for match(), embodying “explicit is better than implicit.” New code should use prefixmatch() for prefix matching, re.search() for unanchored matching, or re.fullmatch() when both ends must match; existing code supporting older Pythons can keep match(). The post includes a comparison table and Ruff config to ban re.match().

Introducing wrapture

Wrapture is a Python library that wraps real code rather than replacing it, enabling observation, testing and monkey‑patching from a single mechanism. Bindings name target methods, a timeline records calls with arguments, return values and call‑graph nesting, and can be queried in tests or streamed to sinks (printer, JSON, OpenTelemetry). The same bindings also support stubbing, raising, argument/result transforms, and ad‑hoc tracing of running applications without code changes.

The Mullet Stack: JavaScript in the front, Python in the back.

The Mullet Stack guide pairs React + TypeScript frontend (Vite) with FastAPI + Pydantic backend, JavaScript in front, Python in back. It walks through parallel setup, defining/validating an Item model, contrasting TypeScript’s build-time structural typing with Pydantic’s runtime validation, testing with Vitest and pytest, handling CORS, and deriving frontend types from FastAPI’s OpenAPI schema via openapi-typescript to prevent drift, noting alternatives like Django, Next.js, GraphQL, and concluding codegen unifies the stack.

Making a Python interpreter in 1024 bytes

The author describes building a Python-like interpreter in just 1024 bytes of C code, targeting a FizzBuzz program with recognizable Python syntax (def, colons, indentation). His first 512-byte attempt failed. Rather than tokenizing/compiling like CPython, he uses global arrays for source and symbols, recursive-descent parsing that executes immediately, the C call stack for indented blocks, and backward jumps re-parsing the source for loops and function calls (even recursion). Heavy “code golf” tricks — single-letter names, ASCII comparisons, bitwise/ternary tricks, C89 implicit ints — shrank a 4800-byte readable version to 1024.

How Libraries Run Rust Inside Python (with PyO3)

The blog post explains how libraries like Pydantic v2 embed Rust in Python using PyO3, demonstrated with a hand-rolled JSON parser. Four steps get Rust into Python: write a Rust module, annotate it with #[pyfunction]/#[pymodule] macros, compile with maturin into a shared library, and import it. The parser returns a Rust JsonValue enum, which Python never sees directly. The key insight: .into_pyobject() must rebuild the entire tree as native Python objects, so on large documents this conversion can cost more than parsing itself. Errors translate via a From impl into Python exceptions. For scalar returns, port freely; for large structures, profile the boundary and consider lazy, Rust-backed views.

Creating temporary files in Python

This article by Trey Hunner explains creating temporary files and directories using Python’s standard-library tempfile module. NamedTemporaryFile creates a file deleted when its with block exits; use delete=False (or Python 3.12’s better delete_on_close=False) to keep the file so other code can use its name, then delete it manually. TemporaryDirectory offers an auto-deleted folder. TemporaryFile returns only a file descriptor, not a real filename, so a named file is usually preferable. Prefer pytest’s built-in temp utilities when available; otherwise use NamedTemporaryFile and TemporaryDirectory.

pytest plugins that actually change how you test in 2026

In this hands-on guide, the author recommends seven pytest plugins that reshape testing workflows in 2026: pytest-httpx mocks HTTP at the transport layer and fails tests when registered mocks go unused; pytest-randomly exposes order dependencies via randomized runs and reproducible seeds; anyio’s built-in plugin simplifies async tests across asyncio and trio backends; syrupy enables snapshot or golden-file testing; pytest-watch reruns tests on file save; freezegun deterministically freezes time, avoiding the outdated pytest-freezegun wrapper; and pytest-cov, configured with branch coverage, skip-covered reporting and thresholds, reveals real gaps. Together they form a free, no-subscription testing stack.

Agentic Engineering in Python: From Vibes to Evidence

This article introduces agentic engineering — delegating bounded coding tasks to AI agents while humans retain ownership of intent, constraints, review, and release. Unlike vibe coding, which accepts plausible-looking output, agentic engineering demands evidence. It centers on two loops: a fast agent execution loop and a slower human acceptance loop. Key tools include the eight-level Engineering Evidence Ladder (from code existing to CI integration) and the RECAP review checklist (Role, Edges, Contracts, Assumptions, Proof). The article also warns against implementation-mirroring tests, scope creep, poor audit trails, and excessive agent access.

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

Repositories

BruceEckel/ThinkingInPython (CC BY-NC-ND 4.0)

An intermediate-to-advanced book for experienced programmers. It opens with a fast introduction for programmers coming from other languages.

reflex-dev/xy (Apache 2.0)

XY is an extremely fast, interactive, customizable Python charting library for the web, notebooks, and static exports. Charts are composed declaratively or through matplotlib conventions. You can fully customize them with Python, CSS, or Tailwind.

gi0baro/tonio (BSD-3-Clause)

TonIO is a multi-threaded async runtime for free-threaded Python, built in Rust on top of the mio crate, and inspired by tinyio, trio and tokio. It supports both using yield and the more canonical async/await notations, with the latter being available as part of the tonio.colored module.

Have time for some fun?

The Move to Python 3 Begins!

EVE Online has begun migrating its 2.4-million-line Stackless Python codebase from Python 2.7, unchanged since 2010, to Python 3 as part of the EVE Forever initiative. First Singularity-tested changes are now live, with success defined as invisibility to players. Motivations include major Python 3 performance gains, access to modern libraries, debuggers and profilers, and cleaner strings, integers and classes. The staged approach first uses Python-Future to make code parse under both versions — 95.9% already does, with only ~3,300 blocking lines — before tackling ~20,000 lines with changed behavior like division.

As we wrap up this journey together, I want to take a moment to express my gratitude for your reading. If you’ve enjoyed this issue and would like to help sustain this blog, please consider starring this blog on github, it would be great motivation for me to keep updating!

Alright, that concludes the September Edition of “This Month for Pythonistas”. Thank you again for reading my post and I hope you enjoy it or find something useful. Happy coding and see you in October! 👋

[PyCon China 2026] It's Time to Learn (Some) Rust — Starting from a Faster pip install

Zeyang Lin — Sat, 05 Sep 2026 07:10:00 GMT

It’s Time to Learn (Some) Rust — Starting from a Faster pip install

Hi everyone! This post is adapted from my lightning talk at PyCon China 2026, “It’s Time to Learn (Some) Rust — Starting from a Faster pip install”. What the subtitle means — I’ll get to that in a moment.

Whether you’ve noticed it or not, Rust is already part of your daily life as a Python developer. uv, ruff, and pyrefly — Meta’s open-source type checker — this new generation of Python tooling is all written in Rust. And plenty of Python libraries are bringing Rust in as well: pydantic v2 rewrote its validation core in Rust and got 17x faster; polars’ entire engine is Rust; cryptography uses it to harden its core. So Rust stopped being “the language next door” a long time ago — it’s hiding inside the dependencies of every pip install you run.

Even CPython’s own source code may soon include Rust. Look at the timeline: in November 2025, the pre-PEP discussion thread opened; in March 2026, the forked CPython project’s CI builds went green on all platforms; and at PyCon US 2026 in May, the working group unveiled zlib-py as the first planned pilot module — a drop-in alternative to the existing zlib module, with decompression running 3 to 6 times faster. If it lands, every pip install you run from then on will decompress faster. That’s where the subtitle comes from.

The bad news: the PEP originally planned for July has slipped. The good news: the reason is nothing external — the design details of the internal Rust API simply deserve to be worked through slowly and carefully. It’s a slip, not a stall. Their target is Python 3.16, in 2027.

So next, let’s see how simple getting started with Rust can be. It’s like the old joke about putting an elephant into a fridge — three steps in total.

Step one: install maturin with uv, then run maturin init — and a Rust project is initialized, ready to be packaged straight into a Python wheel.

Step two: in lib.rs, write a function that computes the n-th Fibonacci number. Only two macros in this code really matter: #[pyfunction] exposes the Rust function to Python, and #[pymodule] registers it as a Python module. The iterative logic in between is essentially the usual way you’d compute Fibonacci in Python — even with no Rust background, you can follow the gist.

Step three: maturin develop. That single command compiles the Rust package, builds a wheel, and installs it into your current Python virtual environment — building, packaging, and installation all in one go, an experience nearly identical to a pure-Python toolchain. Then it’s back to Python: import fibonacci_rs, call fibonacci(88), and the 88th Fibonacci number comes right out.

One sentence to sum it up: Python handles the orchestration; Rust does the computing.

Now, some of you may feel that computing Fibonacci numbers is a bit too simple — barely a step above Hello World.

So let’s look at a somewhat more involved example: the Julia set. In short: take every point in the complex plane, repeatedly apply z = z² + c (with c a fixed complex number), and see which points never fly off to infinity (modulus above a threshold).

In my concrete example, the canvas is 1000×1000 — one million points in total, each iterated at most 300 times. In the figure, the black areas are points that escaped quickly; the brighter the region, the more iterations it took to escape; and the white, snowflake-shaped region in the middle marks points that still hadn’t escaped after 300 iterations. This is a CPU-bound task — precisely the territory where Python is considered relatively weak.

We start with the pure-Python version: an honest, plain double loop. A run of line_profiler makes the picture stark: this one function devours 96.1% of the program’s total time, while the two list operations above it — each executed a million times — account for just 1.4% and 1.5% respectively.

Still using maturin, we write a Rust function, calculate_z_serial, that mirrors the pure-Python function roughly one-to-one in logic.

Once it’s written, the Python script needs exactly one added import line and one changed function name — that’s it. From the caller’s point of view, the function signature and behavior are completely unchanged.

Now we run line_profiler again: the function’s share of runtime drops from 96% straight down to 18% — the biggest time sinks are now Python’s for loops and list operations — and the script’s total runtime falls from 3.008 seconds to 0.144 seconds, a speedup of more than 20x. And that’s with a faithful serial port of the original; bring in Rayon for multithreaded parallelism, and the speedup tops 100x.

If, after these two examples, you’d like to try building something in Rust, it’s worth first understanding the four mindset hurdles that lie between writing Python and writing Rust.

First, from recommended explicitness to enforced explicitness: Python’s “explicit is better than implicit” is advice; Rust makes it law — mutating data requires declaring mut, match must be exhaustive, and if you don’t comply, it refuses to compile.

Second, from referencing data to owning it: in Python, assignment is sticking a name tag on an object — share it freely, and the GC cleans up. In Rust, every value has exactly one owner, and whether it’s moved or borrowed is checked with total clarity at compile time.

Third, from EAFP to LBYL — from “easier to ask forgiveness than permission” to “look before you leap”: Rust writes “can this fail?” into the types. With Option and Result, you can’t touch the value without checking it first.

Fourth, from the GIL to real concurrency: data races become compile errors — if your program compiles, it is guaranteed free of data races.

Here’s a reference roadmap for learning Rust, in four stages.

Stage one, syntax bridging — with a Python foundation, you’ll get up to speed quickly.

Stage two is the climb: ownership, borrowing, error handling, traits, closures — possibly the most painful stretch of the entire journey, but push through it and the change is qualitative.

Stage three, concurrency. std::thread has you writing real multithreaded code; shared mutable state gets the standard Arc-plus-Mutex combo; and whether data may cross thread boundaries is policed by the compiler through Send/Sync. Want to keep it easy? Rayon turns a loop into data-parallel execution with one line; for I/O-bound concurrency, there’s tokio, the async runtime.

Last and most important: hands-on practice. Use maturin to rewrite a hot function from your own project — profile to locate it, test for parity, benchmark to compare — closing the loop.

As we all know, writing code while you learn is one of the most effective ways to surface problems and consolidate knowledge. These are the three tools I found most helpful as a beginner: Rustlings — around ninety bite-sized exercises straight from the official project, a few minutes each, running locally; and Codewars and LeetCode, which both let you solve problems in Rust directly. Re-solving problems you previously did in Python — this time in Rust — makes the differences between the two languages far easier to internalize.

So does this mean all your Python code should become Rust? Before you start, remember: profiling first — confirm the bottleneck before talking about a rewrite. Don’t go on a hunch.

Good candidates for a rewrite: CPU-bound modules with clear boundaries that process untrusted input; I/O-bound code and glue code can often stay as they are.

Before you dive in, also look at the alternatives: a better algorithm, a free-threaded build, an existing third-party library — or Cython, Numba, or GPU acceleration. Any of these may be the better deal.

Of course, real-world decisions are more complicated — team skills and migration cost come into play, among other factors. And remember this line: Rust is not a “press for speed” button — speed has always been the reward for choosing the right problem.

If you still feel Rust is too hard to learn, consider it from another angle: even if you never write production-grade Rust, the time is not wasted. Explicit types, ownership, explicit error handling, exhaustive matching — these habits of mind transfer back and make your Python more rigorous.

OK, to wrap up. Rust is not Python’s rival — it’s Python’s partner: Python for orchestration, Rust for speed and safety. And learning Rust is more than an investment in personal skills: judging by the progress of Rust for CPython, it may be your ticket to contributing to CPython. The next Rust for CPython contributor might well be you, reading this article right now.

Of course, this talk would not exist without the valuable material left behind by pioneers in the community — Microsoft’s Rust for Python Programmers course, plus several excellent talks and articles, all listed below. My thanks to all of them.

Microsoft — Rust for Python Programmers (open course)
Daroc Alden — “Eventual Rust in CPython”
Bob Belderbos — “Learning Rust Made Me a Better Python Developer”
Daniel Szoke — “Why You, a Python Developer, Should Learn Rust”
Emma Smith — “Rust for CPython: Making Python Safer and More Robust for Everyone”
Micha Gorelick & Ian Ozsvald — High Performance Python, 2nd Edition

That’s the whole talk. The demo code is on GitHub, and if you’re interested, you’re welcome to find me on any of these platforms to keep the conversation going. Thanks for reading!

This Month for Pythonistas - August 2026

Zeyang Lin — Mon, 31 Aug 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 8

Welcome back Pythonistas! This is the August 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts, repositories and community highlights for this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

DjangoCon US 2026

DjangoCon US 2026 took place in Chicago at the voco Chicago Downtown from August 24–28, 2026. It featured in-depth technical talks, hands-on workshops, Open Spaces, and community sprints. Key session topics spanned web development, Django 6.x features, API integration, deployment, security, testing, HTMX, and AI integration within the Django ecosystem. Attendees also engaged in networking, hallway discussions, and collaborative open-source contributions throughout the week.

Django is moving to an annual release cycle

Django’s Steering Council accepted DEP 20 to move Django to an annual release cycle starting January 2028, with one feature release per year carrying three years of LTS-level support and version numbers reflecting the release year (e.g., Django 2028, 2029). Every release becomes an LTS with three years of support (one year mainstream bugfixes, two years security fixes), retiring the old “LTS” label. The new cycle aligns better with Python’s annual October releases, with each Django version supporting the three latest Python versions. API stability and deprecation policies remain unchanged, and the transition begins with Django 6.1 (Aug 2026) and 6.2 LTS (Apr 2027) as the final releases under the old cycle.

Qwen3.8-Max: A New Bar for Coding and Cowork

Qwen3.8-Max is officially released as the most capable model in the Qwen family, scaling to 2.4 trillion parameters and delivering comprehensive improvements across coding, work, research, and long-horizon tasks. It is the first open-weight Qwen-Max-class model, with weights released on HuggingFace and ModelScope. Key capabilities include autonomous coding (building a self-evolving harness over 10+ days), reproducing and improving research papers (beating the original by +2.7 points on AIME24), and outperforming 87% of human teams in the WWW2025 challenge. It also excels at real-world work tasks, long-horizon planning (autonomous chip design, e-commerce operations), and multimodal agent tasks with visual feedback loops.

GLM-5.3: Frontier Coding with Emergent Cyber Capabilities

GLM-5.3 is a frontier coding model that uses the same base as GLM-5.2 but achieves major gains through scaled post-training alone. It is the most capable open-weights model for coding — 50% better than GLM-5.2 on Z.ai’s Code Bench and state-of-the-art on Terminal Bench 3.0 and Agents’ Last Exam — while also showing emergent cyber capabilities, scoring best on CyberGym and more than doubling GLM-5.2 on exploitation benchmarks. The model identified 2,436 vulnerabilities across 269 real-world projects, and its open-source weights will be released in two weeks.

Introducing Gemini 3.7 Flash

Gemini 3.7 Flash is Google’s most intelligent workhorse model for coding and agents, released three weeks after Gemini 3.6 Flash based on developer feedback. It delivers substantial improvements in software engineering, knowledge work, and web development at half the original 3.6 Flash cost. The model achieves strong gains in coding benchmarks (FrontierCode 1.1: 43.6% vs 34.4%; DeepSWE v1.1: 65.3% vs 49.0%), outperforms 3.6 Flash on WebDev Arena (Elo 1588 vs 1538), and excels in knowledge-dense fields like finance and law (GDP.pdf: 34.0% vs 22.0%).

New Versions

Python 3.15.0 candidate 1 is here!

This is the first of two planned candidate releases. Entering the release candidate phase, only reviewed code changes which are clear bug fixes are allowed between this release candidate and the final release. The next release of Python 3.15 will be 3.15.0rc2, scheduled for 2026-09-01.

The source tarballs and binary distributions can be downloaded here.

Python 3.14.7 and 3.13.15 are now available!

Python 3.14.7 is the seventh maintenance release of 3.14, containing around 499 bugfixes, build improvements and documentation changes from 86 contributors since 3.14.6. Python 3.13.15 is the fifteenth maintenance release of 3.13, containing around 400 bugfixes, build improvements and documentation changes since 3.13.14.

Python 3.12.14, 3.11.16 and 3.10.21 are now available!

These are new security releases for 3.12, 3.11 and 3.10, respectively, addressing numerous security vulnerabilities.

Tutorials

deeplearning.ai’s AI Coding Workflows: From Cloud to Local by Paul Everitt

You’ll use the same Python app to put each setup to the test: first from a Claude Code baseline, then with subagents that break the job into focused tasks, then with a cheaper model doing the routine work. From there you’ll switch to an open-source coding agent, connect it to different inference providers, and finally run models locally.

RealPython’s How to Integrate OpenTelemetry With a FastAPI App

Adding observability to your applications is crucial for diagnosing issues in production. In this tutorial, you’ll learn how to integrate OpenTelemetry — an open-source observability framework — into a FastAPI application. After following along, you’ll be able to instrument FastAPI with OpenTelemetry to export traces and correlate them with your application logs, allowing you to explore your telemetry in a dedicated dashboard.

Articles

Why the Hardest Concept for Python Devs Is Concurrency: asyncio vs threading vs multiprocessing

This article explains why concurrency is one of the hardest concepts for Python developers, covering how operating systems manage processes and threads, the role of the kernel and system calls, and how CPUs execute code in user and kernel modes. It explores Python’s Global Interpreter Lock (GIL), which prevents multiple threads from running Python bytecode simultaneously, and compares three concurrency approaches: asyncio (cooperative multitasking via an event loop for I/O-bound work), threading (preemptive multitasking for I/O-bound tasks that release the GIL), and multiprocessing (true parallelism for CPU-bound work). The article also discusses CPU vs. GPU specialization, Amdahl’s Law, profiling tools like Python 3.15’s Tachyon sampler, and practical guidance for choosing the right concurrency model in real applications like FastAPI.

Scaling NumPy on Free-Threaded Python

Scaling NumPy on free-threaded Python required eliminating multi-threaded bottlenecks that prevented linear scaling across cores. Profiling revealed five key issues: lock contention in tracemalloc (fixed with atomic operations), lock contention in the ufunc dispatch cache (replaced with a lock-free concurrent hash map), reference count contention on global PyCapsule objects (resolved by making the default memory handler immortal), module attribute lookup contention (enabled bytecode specialization for __getattr__ modules), and memory allocator contention (routed NumPy allocations through CPython’s raw allocator backed by mimalloc). Coordinated changes across both NumPy and CPython yielded dramatic results — multi-threaded performance at 32 workers improved from ~44 seconds to ~1.5 seconds, outperforming multi-processing by 4x.

Running subprocesses in Python

The article explains how to run subprocesses in Python using the subprocess module, primarily the subprocess.run() function. It covers launching external programs by passing commands as a list of arguments or a string with shell=True, capturing subprocess output using capture_output=True, decoding bytes to text with text=True, checking the returncode to detect errors, and using check=True to automatically raise CalledProcessError exceptions on non-zero exit codes. The article also recommends creating custom wrapper functions around subprocess.run() to reduce repetitive keyword arguments when running multiple subprocesses in a script.

Two lines of Python that segfault the interpreter

This post describes a CPython crash caused by a type confusion in the SET_ADD bytecode opcode, triggered by PEP 749’s conditional annotations feature. PEP 749 introduced lazy annotation evaluation, requiring a __conditional_annotations__ set to track executed annotations — but this set is an ordinary module global that user code can rebind. When reassigned to an int, SET_ADD (which skips type checks, assuming its operand is a stack-allocated set) casts the int to a PySetObject* and dereferences invalid memory, causing a segfault with no traceback. The fix differs by branch: on main, a dedicated add_conditional_annotation intrinsic with its own type check replaces SET_ADD for annotations; on released 3.14/3.15 branches, SET_ADD was patched to verify the operand is actually a set. The author notes that implicit compiler guarantees are fragile contracts — a safe invariant for one caller can silently become a vulnerability when a new caller appears.

When str.lower() is a security vulnerability in Python

This post from Seth Larson describes a Python security vulnerability (CVE-2026-17084) involving str.lower(). The IDNA 2003 standard (str.encode("idna")), built on StringPrep from RFCs 3491/3454, requires case-folding per Unicode 3.2.0 tables B.2/B.3. However, Python’s implementation calls str.lower(), which uses whatever newer Unicode version ships with the interpreter, causing certain characters (like Cherokee U+13A0) to encode differently than the specification requires — a divergence exploitable as a vulnerability. The fix added exception mappings emulating Unicode 3.2.0 behavior; credits go to Bitshift, Stan Ulbrych, Marc-Andre Lemburg, and Petr Viktorin.

Binary search in Python with bisect

Python’s bisect module provides built-in binary search for sorted lists, offering O(log n) performance far faster than linear iteration. The article explains binary search conceptually through a number-guessing game, clarifies that “bisect” means cutting into two pieces, and details the module’s core functions (bisect_left, bisect_right, insort_left, insort_right) and their aliases. It covers practical recipes like finding exact matches, counting duplicates, locating first/last matches, and finding the closest value, while emphasizing that binary search excels at inexact or range-based lookups that sets and dictionaries cannot handle efficiently.

Celery: from first task to advanced recipes

Celery is a mature distributed task queue system for Python that enables decoupled producer-consumer integration. This article covers its core concepts — brokers and backends, task definition, and worker configuration — along with practical recipes: running tasks from the command line and code (including remote calls via send_task), using Canvas signatures and groups for batch execution, configuring queues, setting time limits (timeout, expires, soft/hard limits), implementing retry logic for transient errors, preventing parallel execution with Redis locks, and awaiting task results asynchronously.

One agent, every surface: how we built the Kiro agent harness

Kiro consolidated three separate agent harnesses (IDE in TypeScript, CLI in Rust, web in Python) into a single unified agent harness running as a standalone server process. Previously, each client had its own agent with incompatible session formats, tools, and permissions, making cross-client session continuity impossible. The new harness communicates with all clients via the Agent Client Protocol (ACP), extended with Kiro-specific features like live steering and rich permissions. This eliminates duplicated effort, ensures consistent behavior across surfaces, and enables features like spec-driven development, custom agents, and hooks to work identically everywhere.

Building an Advanced Agentic Harness

The article explains how to upgrade a basic agentic harness into a production-grade system by composing small, testable primitives rather than hiding mechanics behind frameworks. It uses an air campaign analogy: just as real operations add mission planners, parallel squadrons, fuel budgets, flight recorders, and after-action reviews around a pilot, production agents need structure around a single LLM call. Key primitives include typed tools with Pydantic validation, a DAG-based planner for parallel execution, tiered memory, a verification hierarchy, multi-dimensional budgeting, and a tracer. Each primitive addresses a specific failure mode of naive agents (invalid arguments, silent errors, context bloat, cost runaway).

Designing Loops for Production-Grade Work

Liquid AI’s blog describes a late-2025 experiment testing whether coding agents could autonomously solve a production-grade problem from scratch. Two agents — Claude Opus 4.5 and Codex with GPT-5.2 — were tasked with building toktoktok, an open-source BPE tokenizer trainer capable of processing trillions of tokens on a single machine. Neither succeeded zero-shot on toy data, but through iterative loops against real production data and an external verification harness (checking tiktoken/Hugging Face compatibility), Claude Opus 4.5 delivered a working solution. Key lessons: write short, constraint-focused specifications leveraging agents’ multi-domain expertise, and design loops that converge against real-world constraints rather than self-reported tests.

The Shapes of Agent Memory – Files, Stores, and Experience

This article compares three architectures for agent memory that persists across sessions: files, structured stores, and trained experience.

File-based memory (used by Claude Code, Cursor, Cline) lets the model curate plain markdown files — a small index plus topic files — and relies on text search for retrieval. It’s easy to ship but limited in scalability.
Structured memory (mem0, Letta, Zep) mines every conversation turn into atomic, embedded facts stored in a vector index and temporal graph, retrieved via ranked similarity. It splits into two lineages: place-organized (MemPalace, files by location) and entity-and-time (Zep’s Graphiti, a bi-temporal knowledge graph).
Experience-based memory (MemHarness, the state of the art) banks episodes but trains the model’s retrieval and usage of them directly into its weights via reinforcement learning.

Key findings: The structured store beat files on both accuracy and token cost; files win when memory is small or when the right answer is “I don’t know.” A hybrid associative graph outperformed a plain vector index on long-haystack benchmarks, though no single benchmark ranks memory systems fairly. On agentic benchmarks, retrieved experience only helped weak actors with headroom; where reasoning alone suffices, a frontier model matched the trained system without memory, and where reward required practice, the trained policy stood alone.

Agent memory as a moat: how context compounds

This Redis blog argues that because LLMs are inherently stateless, persistent agent memory — storing facts, experiences, and procedures across sessions — transforms static RAG retrieval into a compounding learning system via a write-manage-read loop. Accurate, well-governed memory grows more valuable with use, creating switching costs and a defensible moat. But governance is essential: scoped namespaces per tenant, retention policies preventing context rot (poisoning, distraction, confusion, clash), and strict access controls against memory injection attacks. Redis supplies fast in-memory infrastructure — vector search, semantic caching, and managed Agent Memory — turning governed accumulated context into a durable competitive advantage.

Introducing Agent Plugins

Agent Plugins 1.0.0 is an open, vendor-neutral standard for packaging AI agent extensions into distributable plugins. It provides a common format using a plugin.json manifest and fixed directory structure for Agent Skills and MCP servers, allowing authors to package components once for use across multiple clients. Version 1 focuses on these two component types, leaving other features like commands and hooks to clients via a namespaced extension mechanism. Initiated by Vercel with AWS, Anysphere, GitHub, Microsoft, and OpenAI, it is supported across ChatGPT, Codex, Cursor, GitHub Copilot, Kiro, and VS Code, and is governed as an open, multi-vendor project.

Software Engineering fundamentals matter more than ever

Despite AI hype, software engineering fundamentals matter more than ever. The author argues that while agentic harnesses and LLMs can now generate working, testable code, they still fall short on the deeper craft: building software that is debuggable, maintainable, layered, and composable. LLMs predict rather than reason, making them vulnerable to prompt injection and poor judgment. The key skill remains carefully choosing abstractions, managing cognitive load, and thoughtfully designing how software components fit together over the long term. The best engineers aren’t those boasting about AI’s power, but those using it as a tool while applying timeless principles of good software craftsmanship.

2x, not 10x: coding with LLMs in 2026

The article argues that LLMs have improved coding productivity by roughly 2x, not 10x, because they excel at producing code that meets verifiable acceptance criteria but still struggle with higher-level questions like code maintainability and documentation quality. The author proposes a “staircase hypothesis”: once LLMs became reliable enough for automated feedback loops, further improvements yield diminishing returns — like being tall enough to climb stairs one step at a time versus two. LLMs are best used for rough drafts, with the author iterating heavily afterward, noting that a working implementation is now only about 20% done rather than 80%. Future gains will likely come from industry retooling around current capabilities rather than model improvements alone.

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

Repositories

RyanCodrai/turbovec (MIT)

turbovec is a Rust vector index with Python bindings, built on Google Research’s TurboQuant algorithm — a data-oblivious quantizer with near-optimal distortion and no separate training phase.

Have time for some fun?

Gamescom 2026

GTA 6 — Take-Two and Rockstar skipped a traditional live stage demo at Gamescom, instead focusing on an extended gameplay breakdown that highlighted modern-day Vice City, its dynamic romance mechanics, and a criminal profile system.
Tomb Raider: Legacy of Atlantis — A 20-minute gameplay demo shown behind closed doors
The Witcher 3: Wild Hunt — CD Projekt Red surprised attendees with a full current-gen Remaster arriving September 2026, alongside a brand-new expansion titled Songs of the Past planned for 2027.
Gears of War: E-Day — Detailed with Unreal Engine 5 gameplay showcases focusing on its co-op campaign, Horde Siege, and multi-player modes.
Showa American Story — Developer NEKCOM Games debuted an absurd, high-energy Gamescom 2026 trailer for this post-apocalyptic B-movie style RPG. The footage showed off Choko fighting through a “Japanified” 1980s America using makeshift weapons like drill-arms and the American flag, alongside stat-boosting mini-games.

Alright, that concludes the August Edition of “This Month for Pythonistas”. Thank you again for reading my post and I hope you enjoy it or find something useful. Happy coding and see you in September! 👋

This Month for Pythonistas - July 2026

Zeyang Lin — Fri, 31 Jul 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 7

Welcome back Pythonistas! This is the July 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts, repositories and community highlights for this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

EuroPython 2026

EuroPython 2026, held in Kraków, Poland from 13–19 July 2026, celebrated the conference’s 25th anniversary and brought together over 1,500 Python developers, researchers, and enthusiasts. The week featured tutorials, technical talks, community sessions, open-source sprints, and networking events. A highlight was its collaboration with EuroSciPy, including joint sprints that connected the wider scientific Python community. Hosted at the ICE Kraków Congress Centre, the event emphasized Python’s growing role in software development, AI, data science, education, and open-source collaboration across Europe and beyond.

Releases now reject new files after 14 days

PyPI now rejects new file uploads to releases older than 14 days, preventing older, long-stable releases from being poisoned if publishing tokens or workflows are compromised. This change, discussed since PEP 740 in January 2024 and accelerated after the LiteLLM and Telnyx supply chain attacks, was implemented on July 8, 2026. Data showed only 56 of 15,000 top projects had published Python 3.14 wheels more than 14 days post-release, indicating minimal disruption. The restriction reduces cleanup work for PyPI admins and prevents releases from ending in an indeterminate compromised state, though defined semantics for closed releases are still pending future standardization via PEP 694 and Upload 2.0.

Planned Updates to the PyPI User Interface

PyPI is rolling out user interface updates over the next few months, introducing a new Security tab for provenance and attestation data, horizontal navigation tabs, a right-placed metadata sidebar, trust-level labeling, and clearer status indicators. Changes are being deployed in four phases on TestPyPI first, allowing community feedback. These visual-only updates require no action from maintainers and automatically map existing attestations to the new UI.

Introducing Claude Sonnet 5

Anthropic announced Claude Sonnet 5, their most agentic Sonnet model yet, capable of planning, using tools like browsers and terminals, and running autonomously at levels previously requiring more expensive models. Its performance approaches Opus 4.8 but at lower prices, with substantial improvements over Sonnet 4.6 in reasoning, tool use, coding, and knowledge work. Safety assessments show fewer undesirable behaviors than its predecessor.

Introducing Claude Opus 5

Claude Opus 5 is now available as a thoughtful and proactive model that approaches the frontier intelligence of Claude Fable 5 at half the cost. It is the new state-of-the-art on coding and knowledge work benchmarks like Frontier-Bench and CursorBench, while remaining behind Mythos 5 on cybersecurity tasks. Opus 5 excels on software engineering, scientific research (especially organic chemistry and protein tasks), and visual outputs, while being the most aligned and safest model to date.

Redeploying Fable 5

After US export controls suspended access to Claude Fable 5 and Mythos 5 on June 12, the restrictions were lifted on June 30. Fable 5 is now available globally starting July 1, while Mythos 5 access resumed for select US organizations. Anthropic strengthened safeguards with improved safety classifiers, proposed a shared industry framework for assessing jailbreak severity, and deepened collaboration with the US government on pre-release testing, information sharing, and joint research.

GPT-5.6: Frontier intelligence that scales with your ambition

OpenAI launched GPT-5.6 series including flagship Solo, balanced Terra and cost-effective Luna across ChatGPT, Codex and its API with global gradual rollout. All models beat competitors like Fable 5 and Claude Opus 4.8 in coding, agent workflows, cyber defense, life science research and office document creation, delivering stronger performance at far lower costs and shorter latency.

It supports Programmatic Tool Calling and Ultra multi-agent parallel processing for complex tasks, boasting advanced UI design judgment and precise template-following document generation. Equipped with OpenAI’s most robust layered safety safeguards, it restricts high-risk cyber/biology features to verified users via Trusted Access without blocking legitimate defensive research. Tiered token pricing applies, alongside optimized prompt caching and beta multi-agent API functions for developers. Internal tests show it greatly accelerates AI research with doubled researcher token usage vs GPT-5.5.

Kimi K3: Open Frontier Intelligence

Kimi K3 is a new 2.8-trillion-parameter open model from Moonshot featuring native vision capabilities and a 1-million-token context window. Built on Kimi Delta Attention and Attention Residuals using Mixture of Experts (16 of 896 experts active), it excels at long-horizon coding, knowledge work, and reasoning. It demonstrated frontier-level performance across benchmarks, notably building a GPU compiler, designing a chip, and creating interactive research reports. The full model weights were then released on July 27, 2026.

Introducing Grok 4.5

Grok 4.5 is SpaceXAI’s smartest model, launched July 8, 2026, built for coding, agentic tasks, and knowledge work. Trained on tens of thousands of NVIDIA GB300 GPUs with curated datasets spanning coding, science, engineering, and math, it excels at engineering benchmarks. Served at 80 tokens per second with twice the token efficiency of leading models, it delivers intelligent results quickly and cost-effectively at $2/M input and $6/M output tokens. It’s available in Grok Build, Cursor, and via the SpaceXAI API console.

New Versions

Python 3.15.0 beta 4 is here!

This release, 3.15.0b4, is the final planned beta release, containing around 298 bugfixes, build improvements and documentation changes since 3.15.0b3. The next pre-release of Python 3.15 will be 3.15.0rc1, scheduled for 2026-08-04.

PyTorch 2.13 Release Blog

PyTorch 2.13 brings major performance and scalability improvements: FlexAttention lands on Apple Silicon with up to 12× speedups and gains deterministic backward on CUDA; CuTeDSL provides a second high-performance code path for Inductor; nn.LinearCrossEntropyLoss fuses linear and loss computation to cut peak GPU memory by up to 4×; a new torchcomms backend improves distributed training fault tolerance and debuggability; FSDP2 enables communication overlap for higher throughput; Python 3.15 wheel support is added; and broader platform gains include ROCm, Armv9-A, and Intel XPU updates.

Introducing Haystack 3.0: Agent Hooks, Skills and a Lighter Core

Haystack 3.0 is a major release of the open-source AI orchestration framework, putting agents at the center. It introduces pre-configured agents (deep research, advanced RAG), hooks for controlling agent behavior, first-class skills with progressive disclosure, built-in introspection and observability, and a leaner core with fewer dependencies.

Tutorials

Deeplearning.ai’s AI Code Reviews

You’ll start with practical techniques for getting more out of AI review, like reviewing before you open a pull request, giving the reviewer task and repository context, and triaging findings by risk. Then you’ll build a context-aware review system of your own, beginning with a context engine that retrieves the most relevant code and extending it into an ensemble of specialized agents.

RealPython’s LangGraph Tutorial: Build Stateful AI Agents in Python

Explore the full tutorial to gain hands-on experience with LangGraph, including setting up workflows and building a LangGraph agent that can autonomously parse emails, send emails, and interact with API services.

RealPython’s CrewAI in Python: Coordinating Teams of AI Agents

CrewAI is a Python framework that lets you build a crew of specialized AI agents, each focusing on one part of the job. For example, instead of cramming research, validation, and writing into a single prompt, you create a team. One agent researches, another validates, and a third writes. Each focuses on what it does best, working together to complete the task.

Articles

PEP 752 – Implicit namespaces for package repositories

PEP 752 is accepted. It introduces implicit namespace reservations for Python package repositories, allowing organizations to reserve name prefixes (e.g., google-cloud-, aws-cdk-) to prevent name-squatting, typosquatting, and dependency confusion attacks. Following the NuGet approach, it works within the existing flat namespace — no new package syntax or installer changes are required, and pre-existing packages are unaffected. Uploads matching a reserved namespace fail with HTTP 409 unless the uploader holds an active grant. The JSON API is upgraded to version 1.5 to expose namespace metadata. The PEP is accepted and has community support from organizations including Apache Airflow, Microsoft, Datadog, pytest, and Project Jupyter.

PEP 814: Add frozendict built-in type

Victor Stinner recounts the long journey to adding frozendict — an immutable, hashable dictionary type — as a built-in to Python 3.15. After his original PEP-416 was rejected in 2012 and PEP-603’s frozenmap stalled, Stinner and Donghee Na wrote PEP 814, which the Steering Council accepted in February 2026. Implemented in C and sharing most code with dict, frozendict preserves insertion order but comparison and hashing are order-independent. The article covers C API additions, stdlib integration (e.g., json, copy, pickle), garbage collector bug fixes, and migration guidance for both Python and C code.

What Every Python Developer Should Know About the CPython ABI

The CPython Application Binary Interface (ABI) underpins Python’s ability to call native C, C++, Rust, or Fortran code and vice versa. This post explains what an ABI is, how it differs from a C API (which is source-level), and details the five layers of the CPython C API—Internal, Private, Unstable, Version-Specific, and Limited. It covers ABI compatibility tags in wheel filenames (cp3XY for version-specific, abi3 for the stable ABI, cp3XYt for free-threaded, and abi3t for the new free-threaded stable ABI in Python 3.15+). The post also explains how the free-threaded build changes the PyObject struct layout, breaking backward compatibility, and how PEP 803 introduces abi3t to let a single wheel target both GIL-enabled and free-threaded interpreters going forward.

When to use classmethod, staticmethod, or instance method in Python

This article explains the differences between instance methods, classmethods, and staticmethods in Python. The key rule: if a method needs the instance (self), it’s an instance method; if it needs the class (cls) but not a specific instance, use @classmethod (e.g., alternative constructors like datetime.date.today(), registries); if it needs neither, use @staticmethod for namespaced helper functions. The author warns that with AI-generated code, methods may look plausible but be structurally wrong, so developers should critically evaluate whether each method truly belongs where it is placed.

Selecting `random` values in Python

The article explains how to generate random values in Python using the random module, which provides pseudorandom numbers via the Mersenne Twister algorithm. It covers randint and randrange for integers, random() for floats between 0 and 1, and choice/choices for picking items from sequences — the author’s most-used function. The deterministic nature allows reproducible results via seed(), useful for testing but risky for security. For cryptographically-secure randomness, Python’s secrets module offers choice, randbelow, and randbits, while the SystemRandom class provides a full secure counterpart to random’s API.

Stacks and queues in Python

Python lists are ideal for stacks (last-in, first-out) using append() and pop(), as they are optimized for adding/removing items at the end. For queues (first-in, first-out), use a deque (double-ended queue) from the collections module, which supports efficient append()/popleft() operations. While deque can also work as a stack, lists are recommended for stack-like needs and deque for queue-like needs in Python.

protobuf-py: Protobuf for Python, without compromises

Buf announced protobuf-py, a new Protocol Buffers library for Python written from scratch. It passes the full Protobuf conformance suite (proto2, proto3, editions), supports extensions, custom options, dynamic messages, and well-known types. Unlike Google’s C-based package, it stores messages as plain Python objects with readable generated code and no runtime dependencies. An optional Rust accelerator boosts parsing/serialization for production workloads. It offers complete spec coverage with an idiomatic Python API, addressing the gap between Google’s complete but clunky package and the nicer but incomplete betterproto.

Pip 26.2: –only-deps solves 16 years of app deployment hacks

pip 26.2 introduces the --only-deps flag, solving a 16-year problem of installing dependencies for application-style Python projects without installing the package itself. The author traces the history of workarounds — from pip freeze, manually cutting version pins, pip install -e ., to third-party tools like pip-chill, pipreqs, poetry, hatch, and uv — showing how community demand finally led to this native solution. Sebastian Höffner’s PR #13895 adds a global flag allowing pip install --only-deps . to install only project dependencies from pyproject.toml, eliminating years of fragile manual deployment hacks.

How to publish to PyPI using GitHub Actions securely

This article by Brett Cannon outlines three steps to securely publish Python packages to PyPI via GitHub Actions: (1) Use the zizmor tool to scan workflows for insecure defaults — set no permissions by default, disable persisted credentials after checkout, and pin actions to commit hashes rather than tags; (2) adopt Trusted Publishing to eliminate API token management and gain attestations; and (3) require manual approval through GitHub Environments to prevent accidental or malicious releases. These measures mitigate recent GitHub Actions security incidents.

uv in production: the speed is real, the integration isn’t free

The article discusses the author’s ~90-day production experience with uv, Astral’s Python package manager. While uv delivers a genuine ~10x speed improvement over pip in CI, the article highlights five key caveats: (1) it refuses to install without an active venv, (2) auto-installing Python is blocked by corporate firewalls (fixable via a mirror), (3) parallel installs get serialized due to locking, (4) it defaults to first-index mode (defense against dependency confusion), and (5) bytecode compilation is off by default, slowing cold starts. The author concludes uv is worth adopting but warns that its deliberate strictness — unlike pip’s leniency — requires budgeting time for integration.

Sandboxing an AI Agent

This post explores sandboxing AI agents by giving them isolated, disposable environments instead of running code directly on a host machine. He compares two architectures: a tool-backend model where the agent loop stays local and the sandbox executes commands remotely, versus the agent-in-the-box model where the entire agent lives inside the sandbox. He examines different isolation strengths—shared-kernel containers, gVisor’s software kernel, and Firecracker microVMs — and concludes sandboxes are becoming a default layer of the agent stack for containment, parallelism, reproducibility, and cheap recovery.

State of CLI Coding Agents, Mid-2026

The article surveys 35 CLI coding agents as of mid-2026, noting the terminal unexpectedly won over IDEs for serious AI coding work. Claude Code’s February 2025 research preview set the template — agentic loop, file/shell tools, memory, hooks, subagents — that everyone else cloned. The landscape spans lab agents (Claude Code, Codex CLI, Antigravity CLI, Grok Build), platform CLIs (Copilot CLI, Cursor CLI, Amp, Junie), and open-source harnesses (OpenCode, Goose, Aider, Cline, Pi/Omp). Open-weight models like GLM-5.2 and DeepSeek V4 narrowed the frontier gap dramatically, while free tiers retreated industry-wide.

What our AI guiding principles actually mean

Wagtail has refreshed its AI guiding principles, emphasizing that AI will remain optional in core with features living in separate packages. The five principles include: no AI dependency in core, a responsible approach focused on ethics and sustainability, model and provider agnosticism favoring open-weight smaller models, only adopting AI where it delivers real value, and maintaining human-in-the-loop control to preserve user autonomy. The article stresses that while the principles are set, the real challenge lies in their practical implementation as AI adoption continues to evolve.

How much can you delegate to agents?

This article presents a framework for deciding agent autonomy levels based on two factors: how easy the task is to check and how cheap it is to undo. It defines four levels—Level 0 (agent as assistant for hard-to-check, costly-to-undo tasks), Level 1 (human-in-the-loop for hard-to-check, easy-to-undo tasks), Level 2 (agent delegation for easy-to-check, costly-to-undo tasks), and Level 3 (self-driving mode for easy-to-check, easy-to-undo tasks) — with real examples from PostHog’s engineering work and practical advice on progressively increasing delegation safely.

The Short Leash AI Coding Method For Beating Fable

The Short Leash AI Coding Method advocates for expert developers to use AI agents cautiously in security-critical software. Unlike “vibe coding” where AI works autonomously, this method keeps the developer actively engaged — reviewing every proposed diff, denying undesired changes, and committing after each subtask. For reviews, both AI and human input are essential: AI catches common mistakes like a linter, while humans handle high-level issues. The key principle is never letting the AI work unsupervised to maintain quality and codebase understanding.

Skill engineering and the case against one-shot AI design

Paul Bakaus, creator of the open-source design skills system Impeccable, argues for “skill engineering” as a new discipline that gives AI agents a precise design vocabulary (e.g., “bolder,” “quieter”) instead of relying on one-shot AI design. He believes agents need domain knowledge and human steering, not full automation. His philosophy: AI quickly produces the first 80% of competent work, while humans own the final 20% where taste and context matter, rejecting the notion of “auto mode” entirely.

Podcasts

🥝 core.py

Episode 30: Live from EuroPython, an Interview with Guido van Rossum

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

🚀 VS Code Insiders Podcast

Episode 23: VS Code’s Agent Host Protocol Explained with Connor Peet

Repositories

mozilla-ai/otari

Open-source, OpenAI-compatible LLM gateway you run yourself. One endpoint for 40+ providers, with virtual keys, budgets, and usage tracking.

Alright, that concludes the July Edition of “This Month for Pythonistas”. Thank you again for reading my post and I hope you enjoy it or find something useful. Happy coding and see you in August! 👋

This Month for Pythonistas - June 2026

Zeyang Lin — Tue, 30 Jun 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 6

Welcome back Pythonistas! This is the June 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts, repositories and community highlights worth noting in this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

An announcement from the Steering Council regarding the JIT project

The Python Steering Council announced that the experimental JIT compiler in CPython must undergo formal review through a Standards Track PEP within six months. While acknowledging the developers’ valuable work and real performance gains, the Council noted the JIT lacks proper formal approval — PEP 744 was only informational. Until an accepted PEP addresses maintenance plans, compatibility guarantees, success metrics, and architectural stability, no new JIT features can be added to main (only bug/security fixes permitted). If no PEP is accepted within six months, the JIT code must be removed from CPython’s main repository.

EuroPython 2026 schedule is revealed 📣

The full schedule for EuroPython 2026, hosted in Kraków, Poland, has been released. Check it out on the official website.

Everything Security at PyCon US 2026

PyCon US 2026 featured its first-ever dedicated security track, “Trailblazing Python Security”, with seven talks covering phishing, zero trust, supply chain attacks, SBOMs, and more. The Python Software Foundation (PSF) delivered a security update highlighting a surge in malware and watering-hole attacks targeting PyPI. An Open Space session brought together open-source maintainers to discuss CI/CD hardening, the overwhelming flood of LLM-generated vulnerability reports consuming most of their time, and the need for contributor quality signals. Additionally, Alpha-Omega–sponsored security roles presented updates on Python Security Response Team governance reforms and efforts to combat supply-chain attacks on the Python ecosystem.

Building a hill-climbing machine: Launching seven new MAI models

Microsoft AI (MAI) announced seven new in-house models during Microsoft Build 2026, spanning reasoning (MAI-Thinking-1), coding (MAI-Code-1-Flash), image generation (MAI-Image-2.5), transcription (MAI-Transcribe-1.5), and speech (MAI-Voice-2). All are trained from scratch on clean data without distillation from third parties. MAI also introduced Microsoft Frontier Tuning, enabling organizations to adapt models to their own workflows using reinforcement learning. A partnership with Mayo Clinic was announced to co-develop a frontier healthcare AI model. MAI’s ultimate vision is “Humanist Superintelligence” — advanced AI designed to serve people, remain under human oversight, and never replace them.

Claude Fable 5 and Claude Mythos 5

Anthropic has launched Claude Fable 5, a Mythos-class AI model that is the most capable model they’ve ever made generally available, achieving state-of-the-art performance across software engineering, knowledge work, vision, and scientific research benchmarks. Due to its powerful capabilities, Fable 5 includes new safeguards that redirect sensitive queries on cybersecurity, biology, and chemistry to Claude Opus 4.8 instead. The company also released Claude Mythos 5, the same model with lifted safeguards for cyber defenders, deployed through Project Glasswing in collaboration with the US government.

Statement on the US government directive to suspend access to Fable 5 and Mythos 5

Shortly after Anthropic released Claude Fable 5 and Claude Mythos 5, the US government issued an export control directive citing national security concerns on June 12th, ordering Anthropic to suspend all access to its Fable 5 and Mythos 5 models for all users, including foreign nationals. Anthropic is complying but disagrees with the decision, stating the government’s evidence involves a narrow jailbreak revealing minor vulnerabilities already discoverable by other models. Anthropic argues its safeguards are robust and that applying this standard industry-wide would halt all frontier model deployments. The company believes this is a misunderstanding and is working to restore access as soon as possible.

MiniMax M3: Frontier Coding, 1M Context, Native Multimodality — All in One Model

MiniMax M3 is MiniMax’s latest frontier model combining three key capabilities: frontier-level coding/agentic performance, 1M-token context via MSA (MiniMax Sparse Attention), and native multimodality (image/video input and desktop operation). It surpasses GPT-5.5 and Gemini 3.1 Pro on SWE-Bench Pro, tops SVG-Bench and Claw-Eval, and excels at real-world tasks like independently reproducing research papers, optimizing CUDA kernels (achieving 9.4× speedup), and autonomously training models. Accompanying the release are MiniMax Code (an agent product), affordable Token Plans, and a tiered API. Model weights and a technical report have also been released.

Qwen3.7-Plus: Multimodal Agent Intelligence

Qwen3.7-Plus is Alibaba’s latest multimodal agent model that unifies vision and language into a versatile agent foundation. It operates as a “multimodal interactive hybrid agent,” capable of perceiving real-world scenes, operating GUIs and CLIs, writing code from visual references, and completing end-to-end tasks. It excels in coding agent benchmarks (Terminal Bench 2.0, SWE-Verified), general-purpose agent tasks, STEM reasoning, and multimodal benchmarks including visual reasoning, search-augmented QA, video understanding, and autonomous driving perception.

GLM-5.2: Built for Long-Horizon Tasks

GLM-5.2 is Z.ai’s latest flagship model designed for long-horizon tasks, featuring a solid 1M-token context window. It introduces IndexShare architecture, reducing per-token computation by 2.9×, and offers flexible effort levels to balance performance and latency. The model excels in coding benchmarks, ranking as the highest-performing open-source model across long-horizon evaluations like FrontierSWE and SWE-Marathon. GLM-5.2 uses advanced RL training with anti-hacking mechanisms and is released under an MIT license.

New Versions

Python 3.15.0 beta 3 is here!

This is the third of four planned beta releases of Python 3.15. Beta 4 is scheduled for 2026-07-18.

Beta 2 was also released earlier this month.

Python 3.14.6 and 3.13.14 are now available!

Python 3.14.6 is the sixth maintenance release of 3.14, containing around 179 bugfixes, build improvements and documentation changes since 3.14.5. Python 3.13.14 is the fourteenth maintenance release of 3.13, containing around 240 bugfixes, build improvements and documentation changes since 3.13.13.

Pyodide 314.0 Release

Pyodide 314.0 has been released, marking a major milestone for Python in the browser. The headline change is the acceptance of PEP 783, enabling package maintainers to publish Pyodide wheels directly to PyPI instead of relying on the Pyodide team to build and host 300+ packages. The project adopted a new Python-version-based versioning scheme (314 = Python 3.14). This release ships Python 3.14.2 and Emscripten 5.0.3, restores several standard library modules, converts Pyodide to a native ES module, adds experimental Node.js socket support, and introduces JavaScript interop improvements including proper bigint roundtripping and enhanced array-like proxy support.

Tutorials

DeepLearning.ai’s Fast & Efficient LLM Inference with vLLM from Red Hat

You’ll run the full optimize-deploy-benchmark workflow on a real model: compressing an open-source Qwen model with LLM Compressor, serving it with vLLM, and benchmarking your deployment under realistic traffic using GuideLLM and lm-eval.

DeepLearning.ai’s Voice for AI Agents and Applications from Vocal Bridge

Taught by Ashwyn Sharma, CEO and Co-Founder of Vocal Bridge (an AI Fund portfolio company), this course covers three practical integration patterns that meet you where you are: voice embedded in an application, voice layered onto an existing agent without touching its logic, and voice as a tool your LLM can call when it decides a conversation is the right modality.

Microsoft’s Rust for Python Programmers

A comprehensive guide to learning Rust for developers with Python experience. This guide covers everything from basic syntax to advanced patterns, focusing on the conceptual shifts required when moving from a dynamically-typed, garbage-collected language to a statically-typed systems language with compile-time memory safety.

If you feel comfortable after learning this book and wish to move on, there’s another book from Microsoft covering async Rust: Async Rust: From Futures to Production.

Articles

Free Threading internals: reference counting

This article by Victor Stinner explores Python’s free-threading reference counting challenges. Python uses reference counting (Py_INCREF/Py_DECREF) to track object lifetimes, requiring high efficiency. The “Gilectomy” project (2016-2018) initially used atomic operations but suffered severe performance issues — 18.9x slower on 7 cores due to lock contention. It later adopted buffered reference counting. The “nogil” project (2021-2026) solved this with Biased Reference Counting (BRC), which recognizes that most objects are accessed by a single thread. BRC uses fast non-atomic operations for the owning thread and slower atomic operations for other threads, achieving better performance at the cost of increased implementation complexity.

Free Threading internals: deferred reference counting

This article continues to explore CPython’s Free Threading internals, focusing on techniques to reduce reference counting contention. Immortal objects (PEP 683) skip Py_INCREF/Py_DECREF entirely, eliminating contention for commonly used singletons like small integers, strings, and built-in types. Deferred reference counting avoids reference count adjustments altogether, relying on the tracing garbage collector for deallocation. Stack references — tagged pointer-sized values introduced in Python 3.13 — allow the bytecode evaluation loop to skip most INCREF/DECREF calls. Together with Biased Reference Counting, these techniques resolve reference count contention, enabling Python threads to scale efficiently across CPU cores.

Free Threading internals: PyMutex

This is the third part in the series regarding Free Threading, in which Victor Stinner discusses PyMutex, a lightweight 1-byte lock introduced in Python’s free-threading implementation (PEP 703), which replaces the Global Interpreter Lock with per-object locks. Designed for efficiency, PyMutex uses only 2 bits and is based on WebKit’s WTF::Lock. It provides fast, inlineable lock/unlock operations using atomic compare-exchange for uncontended cases. Benchmarks show PyMutex is 1.4x to 4x faster than the previous PyThread_type_lock. The implementation uses _PyParkingLot APIs (futex-like) and supports various locking flags. In practice, the critical section API is preferred over direct PyMutex usage to avoid deadlocks.

Python 3.14 garbage collection rigamarole

Python 3.14.0 replaced its traditional generational garbage collector with an incremental GC that reduced maximum pause times by scanning only part of the old generation per collection cycle. However, by doing less work each run, the incremental GC caused memory to accumulate in certain workloads — especially those generating cyclic garbage — leading to significantly higher peak memory usage and potential OOM kills. After users reported “memory pressure”, the Python team reverted the change in Python 3.14.5. Notably, the GC change was not implemented as a switchable alternative and bypassed the standard PEP process, leaving users who benefited from it with no option to use it.

Two Python Scoping Bugs: A Lesson in Object Lifetimes

This blog post illustrates two Python scoping bugs caused by mismatched object lifetimes. The first is over-sharing: a module-level SQLAlchemy engine shared across tests causes state leaks (e.g., auto-increment IDs carry over). The fix is creating a per-test engine using an in-memory SQLite database. The second is under-sharing: a FastAPI dependency that instantiates a new FakeDataSource per request gives each browser tab its own diverging simulator state instead of a shared reality. Fixes include @lru_cache or app.state for shared runtime state.

Down The Iterator Rabbit Hole

This article explores Python iterator chains and how consuming values from one iterator affects others in the chain. Iterators don’t store data — they create lightweight streams that fetch from the original source on demand. When you chain iterators (e.g., a list → first_iter → second_iter → third_iter), calling next() on any iterator in the chain consumes values that propagate through all dependent iterators. The author demonstrates how this can cause unexpected behavior, since iterators are one-way streams. The key takeaway: when building iterator chains, only use the final iterator to avoid confusion. Independent iterators from the same source, however, remain unaffected by each other.

Choosing a Python task queue library in 2026

This article compares five Python task queue libraries in 2026: Celery, Dramatiq, FastStream, Taskiq, and Repid. It evaluates them across broker support, async vs. sync capabilities, throughput benchmarks for both I/O-bound and CPU-bound workloads, and features like dependency injection, result backends, AsyncAPI integration, and retry handling. The author (Repid’s creator) finds that async-native libraries like Repid, FastStream, and Taskiq outperform sync-first Celery and Dramatiq in I/O-heavy scenarios, while differences shrink for CPU-bound tasks. Recommendations: Celery for the largest ecosystem, FastStream for stream-processing patterns, and Repid for high-throughput asyncio-native workloads.

How and why to run modified Python code using the ast module

This Pydantic blog demonstrates how to use Python’s ast module to parse, transform, and execute modified Python code at runtime. Using the eval-type-backport library as an example, it shows how to convert newer type syntax like X | Y into typing.Union[X, Y] for older Python versions by manipulating abstract syntax trees with ast.NodeTransformer. The author shares how mastering AST metaprogramming helped him land jobs at Grist and Pydantic, and argues this skill is increasingly valuable in the AI era since it’s harder to automate and essential for inspecting and controlling code produced by AI agents.

Why I wrote PEP 832 – virtual environment discovery

Brett Cannon proposes PEP 832 which addresses the challenge of virtual environment discovery for tools like VS Code. The problem: editors struggle to know which workflow tool (Poetry, uv, Hatch, etc.) a project uses and where environments are stored, making it difficult to run code and analyze dependencies. Proposed solutions include using .venv directories for local discovery, a .python-envs file listing environment paths, and a [workflow] table in pyproject.toml with a workflow server protocol (WSP) for tool communication. The goal is creating a tool-agnostic standard that simplifies environment setup across all editors, not just VS Code.

Vulnerability and malware checks in uv

Astral announces two new security features for uv: uv audit, a native command that scans dependencies for known vulnerabilities and deprecated packages — serving as a 4x–10x faster alternative to pip-audit — and a lightweight malware check integrated into sync operations (uv add, uv sync, etc.) that queries OSV for known malicious packages, blocking installation before harmful code executes. Both features are currently in preview. The post explains the growing importance of supply chain security, distinguishes malware remediation from ordinary vulnerability patching, and outlines future plans including tighter tooling integration, improved finding precision, and support for additional vulnerability backends and packaging formats.

Give your agent its own computer

LangChain’s LangSmith Sandboxes solve a critical problem: AI agents need real computers to execute code, but giving them access to your infrastructure is dangerous. Containers aren’t secure enough for untrusted, model-generated code. LangSmith Sandboxes provide hardware-virtualized microVMs—each agent gets its own isolated computer with filesystem, shell, package manager, and persistent state. Features include instant startup, snapshots for forking sessions, pre-warmed blueprints, and secure credential injection. This enables production-ready coding assistants, CI agents, data pipelines, and RL training environments that can scale from zero to thousands of instances.

A Practical Guide to Becoming an AI-Native Engineer

This ByteByteGo article presents a practical guide for engineers transitioning to AI-native engineering. Rather than replacing engineers, AI shifts their role from code writers to orchestrators who command AI agents for 100x output. The guide outlines four core practices: context engineering (curating project-specific AI inputs), specification-driven development, critical verification (since ~45% of AI code contains security flaws), and problem decomposition. It recommends spending 40% of time on context-setting, 20% on generation, and 40% on verification. The article also details a three-phase individual transformation journey, team cultural foundations, an Agentic Development Life Cycle, and essential security guardrails against emerging AI-code threats.

Beyond code generation: rethinking engineering productivity in the age of AI agents

Dropbox’s blog post argues that AI coding tools, while boosting code generation, merely shift bottlenecks downstream — into code review, CI, validation, release coordination, and production operations. Their internal agent platform, Nova, now generates ~1 in 12 pull requests, handling tasks like migrations and bug investigation within guardrails. The key insight: AI doesn’t eliminate bottlenecks but relocates them. Dropbox rethinks productivity measurement through a four-stage model — Fuel, Adoption, Output, and Impact — emphasizing customer value over raw PR throughput. Engineers’ roles evolve toward defining intent and reviewing outputs. Ultimately, success depends not on having the best models but on building the best systems around them.

Don’t rely on instructions, use Agent Hooks to enforce guardrails

This blog post demonstrates “Agent Hooks” as deterministic guardrails for AI coding agents like Claude Code, arguing that text-based instructions (e.g., in CLAUDE.md) are unreliable since agents often ignore them. Unlike git hooks that run after code is written, agent hooks intercept the agent’s workflow in real time. The author demonstrates two practical hooks: a PreToolUse hook that blocks raw <input> tags, forcing use of custom design components, and a Stop hook that prevents the agent from declaring completion until a design-system ratchet test passes. Both provide guaranteed, deterministic enforcement that prompt-based instructions cannot.

How to Keep Your Developer Instincts When AI Writes the Code

The author argues that while AI tools promise to eliminate friction in software development, this friction is essential for building engineering intuition and judgment. He categorizes friction into three types: worth deleting (boilerplate), worth keeping (debugging, design decisions), and worth seeking out (deliberate practice). To avoid losing critical thinking skills, developers should adopt deliberate practices like forming expectations before prompting, carefully reviewing AI diffs, and coding without agents weekly. This routine is especially crucial for junior developers to build foundational skills and maintain the craft of engineering in an AI-driven era.

The Speed of Prototyping in the Age of AI

The author reflects on how AI coding agents have transformed his prototyping workflow. Previously, his bottleneck was the time needed to scaffold projects; now, AI removes that friction, enabling him to ship far more functional prototypes—citing projects like the Sakoa programming language, the Kato notation format, and others. He estimates roughly 4x faster output, but the bigger shift is qualitative: he now thinks at a higher abstraction level, focusing on system boundaries and specifications rather than line-by-line implementation. This skill — clearly delegating work — transfers to managing people too. However, he deliberately carves out time for manual coding to stay sharp, and remains cautious about AI’s broader environmental, financial, and social implications.

Domain Expertise Has Always Been the Real Moat

The article argues that domain expertise, not coding ability, has always been the true competitive moat in software development. Agentic AI has severed the link between understanding a domain and producing code, making code generation cheap while domain knowledge remains scarce. A domain expert with no coding background can now be remarkably effective with AI tools because they can verify whether outputs are correct. Conversely, a skilled generalist engineer lacking domain knowledge cannot distinguish plausible-but-wrong answers from right ones. The author advises experienced engineers to invest in deeply learning a real domain — whether regulatory, industrial, or scientific — as that verified domain model is the one thing AI cannot supply and is now the most valuable asset.

Software Is Not A Single-Player Game

This blog post argues that software development is inherently a multiplayer game, not a solo endeavor. The author contends that code review — not design docs — is where the most consequential engineering judgments are made. As AI makes producing code dramatically cheaper, the primary artifact of collaboration is shifting from abstract documents to real, working changes. Teams can now reason about actual implementations rather than proxies, making review more central, not less. While some decisions still require upfront planning, that boundary is shrinking. The author traces this collaborative pattern back to Linux’s early patch-review culture and concludes that building lasting software has always depended on groups exercising shared judgment together over concrete code changes.

AI’s brave new world of technical debt

This article argues that AI agents are creating a dangerous new form of technical debt in software development. Agents automate tasks by adding layers of delegation — MCP servers, prompts, and auto-managed dependencies — but each layer becomes a dependency and a security risk. Studies show AI agents select vulnerable package versions more often than humans and even hallucinate non-existent dependencies. While tools like Anthropic’s Claude Mythos can cheaply discover zero-day exploits in old code, the article urges teams to adopt disciplined practices: minimize their attack surface, version-control prompts, and treat all AI integrations as production dependencies requiring rigorous review and governance.

Vibe Coder vs Software Engineer

This article distinguishes between “vibe coders” and “software engineers” in the age of AI-assisted development. A vibe coder focuses on rapid prototyping and measuring time to a working demo, while a software engineer prioritizes “time to safe merge” — encompassing code review, testing, ownership, rollback, and long-term maintainability. The author argues that AI-generated code must meet the same standards as hand-written code, and that engineers must fully own and understand what they submit, since AI cannot take accountability. Vibe coding suits discovery and ideation, but production delivery demands engineering discipline, bounded tasks, and human judgment built through apprenticeship and system knowledge.

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

Repositories

LvcidPsyche/auto-browser (MIT)

Auto Browser is an MCP-native browser control plane for authorized workflows. It gives MCP clients, LLM agents, and operators a shared Playwright browser with human takeover, reusable auth profiles, approvals, audit trails, and local-first deployment.

NVIDIA/SkillSpector (Apache-2.0)

Security scanner for AI agent skills. Detect vulnerabilities, malicious patterns, and security risks before installing agent skills.

microsoft/coreutils (MIT)

A Microsoft-maintained build of uutils/coreutils, findutils, and grep packaged as a single multi-call binary for Windows. The goal is to make moving between Linux, macOS, WSL, containers, and Windows frictionless.

Have time for some fun?

Sony’s State of Play (2026-6-2)

God of War: Laufey, the title from Santa Monica focusing on Kratos’ wife, is coming to PS5 with release date unknown.
Phantom Blade Zero, the fast-paced action RPG from S-Game, is delayed to October 29th, 2026 with full trailer and pre-order available soon in summer.
Control Resonant, the sequel to Control (2019), is coming September 24th, 2026.
Tomb Raider: Legacy of Atlantis, another “remake” of the first Tomb Raider game, is coming February 12th, 2027.
Onimusha: Way of the Sword from Capcom launches this September, with a playable demo available right now.
Ace Combat 8: Wings of Theve from Bandai Namco is coming this October.
Until Dawn 2 is announced, “featuring a brand new cast, a whole new world to explore, and gut-wrenching decisions”.

Summer Game Fest

Resident Evil Veronica, the remake of Resident Evil: Code: Veronica (2000) from Capcom, follows Claire Redfield searching for her brother Chris and is coming in 2027 to PS5, Xbox Series X|S, Nintendo Switch 2, and PC.
Final Fantasy VII Revelation, the third and final chapter in the FF7 Remake trilogy from Square Enix, adds Vincent and Cid as playable party members with a new Job Class system, and launches Spring 2027 on PS5, Xbox Series X|S, PC, and Nintendo Switch 2 with day-one multiplatform release.
Stellar Blade: Blood Rain, the sequel to Stellar Blade from Shift Up, introduces new protagonist Evie and continues the story beyond the first game, with Shift Up self-publishing this time and no platforms or release date confirmed yet.
Guild Wars 3 from ArenaNet, the first new entry in the franchise since 2012, is set over a thousand years before the original Guild Wars in the land of Orr, featuring momentum-based movement and coming to PC and PS5 (the series’ first console release) with beta in Fall 2027.
Trine 6: Together in Time from Frozenbyte, featuring two new playable characters Moira and Adrius alongside the classic trio, supports 1–4 player co-op and launches September 17, 2026 on PC, Nintendo Switch, Nintendo Switch 2, PS5, and Xbox Series X|S.
Alien: Isolation 2 from Creative Assembly and SEGA, set on a remote storm-ravaged colony world at Kurosaki Station with both interior and exterior environments, is coming in 2027 to PS5, Xbox Series X|S, Nintendo Switch 2, and PC.
Blood Message from 24 Entertainment and NetEase, the publisher’s first AAA single-player title, is a cinematic action-adventure set in 848 AD Tang Dynasty China where a nameless messenger and his son embark on a perilous 1,000-mile odyssey to Chang’an, coming to PC and consoles with no release date yet.
Hitman Classic Trilogy Remastered from Saber Interactive and IO Interactive, collecting Hitman: Codename 47, Hitman 2: Silent Assassin, and Hitman: Contracts with upgraded visuals and a graphics toggle, is coming to PC, PS5, and Xbox Series X|S in 2027.

Alright, that concludes the June Edition of “This Month for Pythonistas”. Thank you again for reading my post and I hope you enjoy it or find something useful. Happy coding and see you in July! 👋

[one-liner] Install OpenCode

Zeyang Lin — Mon, 29 Jun 2026 09:06:00 GMT

One-Liner series: OpenCode

source: OpenCode documentation

Install on Linux, macOS

curl -fsSL https://opencode.ai/install | bash

Install on Windows

Install with npm

npm install -g opencode-ai

Install with chocolatey

choco install opencode

Verify installation

opencode --version

Update

opencode upgrade

[one-liner] Install Bun

Zeyang Lin — Sat, 13 Jun 2026 08:20:00 GMT

One-Liner series: Bun

source: Bun docs

Install on Linux and macOS

curl -fsSL https://bun.com/install | bash

Install on Windows (PowerShell)

powershell -c "irm bun.sh/install.ps1|iex"

Update

bun upgrade

[one-liner] Install pnpm

Zeyang Lin — Thu, 11 Jun 2026 08:20:00 GMT

One-Liner series: pnpm

source: pnpm docs

Install on POSIX systems (except Intel Macs (darwin-x64))

curl -fsSL https://get.pnpm.io/install.sh | sh -

Install on Windows (PowerShell)

Invoke-WebRequest https://get.pnpm.io/install.ps1 -UseBasicParsing | Invoke-Expression

Update

pnpm self-update

This Month for Pythonistas - May 2026

Zeyang Lin — Sun, 31 May 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 5

Welcome back Pythonistas! This is the May 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts and community highlights.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

PyCon US 2026

PyCon US was held in Long Beach, California this May with 2000+ total attendees, 57% of which were first-time. It was a great success - thanks to PSF and the whole community - and I look forward to PyCon US 2027 already (still in Long Beach)! You can check out social media (X, Mastodon, BlueSky, etc.) for highlights.

The recordings of the conference would be published to PyCon US Youtube channel later this year.

Introducing Claude Opus 4.8

Anthropic introduced Claude Opus 4.8, an upgrade over Opus 4.7 with improved benchmark performance across coding, agentic skills, reasoning, and knowledge work, at the same price. Key improvements include greater honesty — Opus 4.8 is roughly four times less likely to let code flaws pass unremarked — and lower misaligned behavior rates. Launching alongside it are: dynamic workflows in Claude Code (enabling massive parallel subagent tasks like codebase-scale migrations), effort control on claude.ai (letting users adjust how deeply Claude thinks), and system entries inside the messages array via the API. Opus 4.8 defaults to high effort, with “extra” and “max” options for harder tasks. Anthropic also teased upcoming cheaper Opus-class models and a more intelligent “Mythos”-class model pending stronger safety safeguards.

New Versions

Python 3.15.0 beta 1 is here!

Python 3.15.0 beta 1 was released on May 7, 2026, marking the first beta and feature freeze. Developers encourage third-party projects to test the preview and report bugs, though it is not recommended for production. Major features include explicit lazy imports, new built-in types like frozendict and sentinel, a dedicated profiling package, default UTF-8 encoding, TypedDict improvements, and an upgraded JIT compiler delivering 8–13% performance gains. Other changes include frame pointers by default, unpacking in comprehensions, and stable ABI for free-threaded builds.

The tarball and binary distributions for beta 1 can be downloaded here. The next pre-release, 3.15.0b2, is scheduled for June 2, 2026.

Python 3.14.5 is out!

This is a very rare patch release due to a release candidate being released several days before the final release.

The incremental garbage collector shipped in Python 3.14.0 - 3.14.4 has been reverted back to the generational garbage collector from 3.13, due to a number of reports of significant memory pressure in production environments.

What’s new in pip 26.1 - lockfiles and dependency cooldowns!

pip 26.1, released April 2026, drops Python 3.9 support and introduces key features: experimental lockfile support via -r pylock.toml (PEP 751), dependency cooldowns with --uploaded-prior-to=P3D, and fixes to the 2020 resolver. Security updates patch archive handling vulnerabilities and upgrade urllib3 to 2.x. The legacy resolver moves closer to removal (planned 2027), and PIP_CONSTRAINT for build dependencies is deprecated for pip 26.2. A future pip sync command is planned to complete lockfile support.

Pyrefly v1.0 is here!

Pyrefly, Meta’s open-source Python type checker and language server, has reached its stable v1.0 release, marking it as production-ready after over 60 minor releases since its alpha launch in mid-2025. Already used at scale by Instagram, PyTorch, NumPy, Pandas, and JAX, Pyrefly delivers significant performance improvements — up to 125x faster incremental editor updates and 34% faster full type checks on large codebases. It offers both CLI and IDE extension support for consistent results across environments, with built-in support for Pydantic and Django, and an upcoming integration with Microsoft’s Pylance via a new Type Server Protocol. The tool supports gradual adoption through configurable presets, migration from Mypy/Pyright, and incremental type annotation via pyrefly infer. Looking ahead, Pyrefly is developing experimental tensor shape checking for ML frameworks and exploring integration into AI-assisted coding workflows.

PyTorch 2.12 Release Blog

PyTorch 2.12 has been released with 2,926 commits from 457 contributors. Key highlights include: batched linalg.eigh on CUDA is up to 100x faster; a new device-agnostic torch.accelerator.Graph API unifies graph capture across CUDA, XPU, and other backends; torch.export.save now supports Microscaling (MX) quantization formats for deploying compressed models; fused Adagrad optimizer joins Adam, AdamW, and SGD; and torch.cond control flow can now be captured within CUDA Graphs. ROCm users gain expandable memory segments, rocSHMEM symmetric memory collectives, and FlexAttention pipelining. TorchScript is now deprecated, with torch.export as its replacement.

Tutorials

DeepLearning.ai’s Build Interactive Agents with Generative UI from CopilotKit

You’ll work across the full Generative UI Spectrum, from hand-crafted components you control precisely, to declarative layouts the agent assembles from building blocks, all the way to open-ended experiences powered by MCP Apps. You’ll finish by building a canvas application where the agent works alongside the user on shared data. By the end, you’ll have a production-ready fullstack agent built on CopilotKit and AG-UI, an open protocol with first-party integrations across LangGraph, Google, AWS, Microsoft, and more.

DeepLearning.ai’s AI Agents for Image and Video Generation from Google

In this course, you’ll learn three complementary evaluation techniques, then combine them with image and video generation to build autonomous media agents. You’ll build an image agent that turns brand guidelines into UI mockups, and a video agent that plans multi-scene explainers, animates reference frames with synchronized audio, and checks consistency across scenes. In the final lesson, you’ll use Gemini CLI to build a generative media agent in natural language, packaging what you’ve learned into reusable agent skills.

Articles

PEP 661 – Sentinel Values

PEP 661 is accepted. It introduces a new built-in sentinel() class for creating unique sentinel values in Python. Sentinel values are special placeholder objects used when a distinct sentinel is needed that’s different from None. The new builtin addresses issues with common sentinel idioms like object() which have uninformative reprs, lack distinct types, and behave unexpectedly after copying or pickling. The sentinel(name) call creates a sentinel with a readable repr, proper identity preservation, pickling support, and type-checking integration. Sentinels are truthy and should be checked with is operator. The feature targets Python 3.15+ with both Python and C API implementations, providing a standardized way to define sentinels throughout the standard library and user code.

Python 3.15: features that didn’t make the headlines

This blog post covers lesser-known Python 3.15 features including: (1) asyncio TaskGroup cancellation — a new tg.cancel() method that simplifies graceful task group termination, replacing the awkward workaround of raising custom exceptions; (2) Context Manager Improvements — ContextDecorator now properly wraps the full lifecycle of async functions, generators, and async iterators, making context managers an ideal way to create decorators; and (3) Thread Safe Iterators — new threading.serialize_iterator and threading.synchronized_iterator functions that enable safe shared iteration across threads, solving issues with skipped values or broken iterator state when using threading or free-threading.

PyCon US 2026 Typing Summit Recap

The PyCon US 2026 Typing Summit featured eight talks and a Typing Council Q&A. Key highlights: Guido van Rossum argued PEP 484’s no-new-syntax rule is already broken and urged prioritizing user pain over power features, citing the 2025 Typing Survey. Jelle Zijlstra proposed intersection and negation types for the spec. Michael Sullivan presented PEP 827 for type manipulation (conditional/mapped types). Douglas Creager showed how ty’s constraint-set solver fixes a partial(choose, None) example all current checkers get wrong. Conner Nilsen found type-checker feedback helps AI agents on well-typed code but not lightly-typed codebases. Jia Chen formalized Python typing in Lean 4, and Avik Chaudhuri demoed tensor-shape types in Pyrefly. The council panel updated on checker landscape (Pyre and pytype winding down) and open spec issues.

I spent 2 years building the async Python task queue I wished existed

The author spent two years developing Repid v2, an async Python task queue that solves the lack of modern async background processing tools. The Python web ecosystem excels with frameworks like FastAPI, but task queues remained antiquated, requiring separate sync contexts and lacking automatic documentation. Repid v1 showed promise but had fundamental design flaws: it was too opinionated about broker capabilities and assumed features like delayed messaging were universal. Production issues with AMQP 0.9.1 prompted the author to write a custom AMQP 1.0 implementation. The v2 redesign embraces simplicity: user-defined message types, broker-agnostic AsyncAPI documentation, and support for multiple brokers including AMQP 1.0, SQS, Kafka, and Redis Streams. Despite modest adoption, the project represents the exact library the author wanted—a self-documenting, truly async message consumer that gets out of the developer’s way.

Learn concurrency - a deep dive into multithreading with Python

This blog post provides a comprehensive overview of concurrency in Python, covering key concepts like multithreading, multiprocessing, race conditions, and synchronization mechanisms such as locks. It explains the differences between sequential, concurrent, and parallel execution, with practical examples. The Global Interpreter Lock (GIL) is discussed as a major limitation preventing true CPU-bound multithreading in Python, though it doesn’t hinder I/O-bound tasks. The article highlights the drawbacks of GIL — such as inability to leverage modern multi-core hardware and the complexity of multiprocessing — and introduces the emerging “free-threaded” build (PEP 703) starting in Python 3.13, which allows developers to disable the GIL and achieve true parallel multithreading.

Behavior-Oriented Concurrency in Python

bocpy is a Python library implementing Behavior-Oriented Concurrency (BOC), a lock-less, deadlock-free paradigm for parallel programming. It uses “cowns” (concurrent-owned variables) to ensure temporal data ownership across sub-interpreters, eliminating traditional locks. Behaviors — decorated functions — declare required cowns and are automatically scheduled for parallel execution, simplifying concurrent code. The library includes a noticeboard for eventually-consistent state sharing and a Matrix class for high-performance numerical operations. bocpy achieves near-linear multi-core scaling via lock-free scheduling and zero-copy data transfer, offering an intuitive alternative to thread-based concurrency.

The Simplest MCP Example Possible in Python

This blog post by Al Sweigart demonstrates the simplest possible MCP (Model Context Protocol) example in Python, showing how to give a local LLM access to external tools. Using FastMCP and Ollama, the author creates an MCP server with two tools — get_current_time and get_current_date — that return the current time and date as formatted strings. A client script connects the Llama 3.2 model to these tools, allowing it to answer time-related questions. The post includes complete code for both the server and client, along with a sample conversation showing the model’s mixed results — correctly answering some questions but also exhibiting common LLM hallucinations, such as incorrectly converting 24-hour time and confidently stating the wrong day of the week.

Using LLMs to find Python C-extension bugs

The article describes how hobbyist Daniel Diniz used Claude Code to systematically discover 575+ bugs in 44 Python C-extensions covering nearly a million lines of code. His cext-review-toolkit employs 13 specialized agents targeting reference-counting, GIL handling, and exception state issues. The approach emphasizes maintainer control, providing high-quality reports with reproducers via secret GitHub gists and adapting based on feedback to minimize false positives. While the reaction has been positive, maintainers note concerns about bug severity and prioritization, suggesting improvements. The article presents this as a responsible example of LLM-assisted bug finding that avoids overwhelming maintainers.

uv is fantastic, but its package management UX is a mess

Astral’s uv is praised for its speed and ability to replace multiple Python tools with one binary, but the author argues its package management UX lags behind peers like pnpm and poetry. Key complaints include: no simple uv outdated command (only uv tree --outdated --depth 1 which displays a cluttered 50-line tree), unsafe default version constraints without upper bounds unlike pnpm’s caret syntax, and awkward upgrade commands requiring repeated --upgrade-package flags. The author welcomes the new --bounds option but notes it’s opt-in and a preview feature. Post-HN reader clarifications noted that uv pip list --outdated exists, --bounds can be set globally in pyproject.toml, and the no-upper-bounds default makes sense for libraries (to avoid dependency resolution issues) but not for applications.

Stop writing edge case tests. Let Hypothesis find them instead.

The author shares how they wrote 47 edge case tests for a URL normalizer, but when they used Hypothesis, it generated 10,000 test cases in 30 seconds and found a critical bug — an all-whitespace URL silently returned an empty string. Unlike conventional tests that check specific inputs, property-based tests define invariants that should hold for any input. Hypothesis generates diverse inputs, shrinks failures to minimal examples, and stores failing cases in a local database for regression testing. The author recommends adding one or two @given tests per function to catch bugs you didn’t know to look for, and provides examples of useful properties like round-trip invariants, idempotency, and monotonicity.

Announcing Genkit Middleware: Intercept, extend, and harden your agentic apps

Genkit, Google’s open-source framework for building AI-powered agentic applications, has introduced a middleware system to enhance reliability, security, and observability. Available in TypeScript, Go, Dart and Python, middleware allows developers to intercept generation calls and tool execution loops to inject custom behaviors. The system offers pre-built solutions including Retry for handling transient errors with exponential backoff, Fallback for switching to alternative models during failures, Tool Approval for human-in-the-loop confirmation of sensitive actions, Skills for dynamically loading contextual knowledge, and Filesystem for scoped file access. Developers can also create custom middleware to enforce specific business rules, such as preventing models from mentioning competitor products, providing a composable way to harden production-ready AI applications.

Inside the Microsoft Agent Framework: How we designed a layered SDK

Microsoft Agent Framework (MAF) is Microsoft’s layered SDK for building production-ready AI agents, which is organized around three core concepts. Agent loops are the fundamental execution cycle where an agent receives input, reasons, calls tools, and iterates until done. Workflows provide structured orchestration for multi-step, multi-agent, or business-critical processes, supporting patterns like sequential flows, handoffs, and author/critic loops. Harnesses supply reusable runtime capabilities — tools, context, memory, planning, permissions, and middleware — that surround the agent and make it practical for real-world use. The framework is provider-agnostic, working across models from Microsoft, OpenAI, Anthropic, and others, and is available for .NET and Python.

The Anatomy of an Agent Harness

This Langchain blog explains that an agent is composed of two parts: a model containing the intelligence and a harness that makes that intelligence useful. A harness includes all the code, configuration, and execution logic around the model. Key harness components include filesystems for durable storage and context management, bash/code execution for autonomous problem-solving, sandboxes for secure isolated execution, memory systems for continual learning, context compaction strategies to prevent context rot, and long-horizon execution features like planning and self-verification loops. The author argues that harness engineering will remain valuable even as models become more capable, as well-designed harnesses optimize model performance for specific tasks. The field continues evolving with active research into multi-agent orchestration, dynamic tool assembly, and self-improving systems.

Agent Skills

This article explores how AI coding agents skip essential senior-engineer practices — specs, tests, reviews, scope discipline — because they optimize for speed, not reliability. The project packages “skills” as workflow-driven markdown files injected into agent context, encoding six lifecycle phases (define, plan, build, verify, review, ship) with concrete exit criteria. Five principles guide design: process over prose, anti-rationalization tables rebutting plausible shortcuts, non-negotiable verification, progressive disclosure to limit context, and strict scope discipline. Skills embed Google-scale practices (Hyrum’s Law, test pyramids, DAMP tests, small PRs, trunk-based development) that agents otherwise ignore. Used as installed slash commands or lightweight runbooks, they force the scaffolding senior engineers provide, turning optional polish into mandatory guardrails for safe, reviewable, ship-worthy code.

How to Work and Compound with AI

The article outlines practical principles for working effectively with AI so that collaboration compounds over time. It argues that every finished artifact — code, docs, analysis, decisions — should become reusable context, while corrections update configurations that reduce future errors. Key practices include organizing work into clear directory structures so models can retrieve relevant context, maintaining annotated indexes and per-project onboarding docs (like CLAUDE.md and INDEX.md) so each session starts with the right knowledge, and separating persistent memory (project state) from personal preferences and workflows. Taste and behavior should be encoded as configuration (global, repo, and project-level CLAUDE.md files), split into lazy‑loaded guides and skills to avoid context bloat. Skills capture repeatable weekly tasks as markdown workflows, bootstrapped by doing a task once and refining it through session transcripts rather than direct edits. Verification is shifted left with deterministic checks, automated tests, and model‑run evals before human review, and long‑running tasks use a “pair programmer” session to detect execution and direction drift. To scale, delegate larger end‑to‑end tasks with clear success criteria and parallel sessions, and make work observable with status signals and remote‑control options. Finally, close the loop by sharing openly, mining transcripts for missing steps or corrections, and periodically refactoring configs to avoid contradictions—the same principles that apply to managing human teams.

Vibe coding and agentic engineering are getting closer than I’d like

Simon Willison distinguishes “vibe coding” — accepting AI‑generated code without review — from “agentic engineering”, where professionals use AI tools to build high-quality systems while maintaining security and maintainability. In this post he observes that the two practices are increasingly overlapping: because AI agents are becoming highly reliable, he now routinely ships production code he hasn’t reviewed, feeling uncomfortable about accountability. He also notes that AI makes it trivially easy to produce polished repos with tests and docs, so real evidence of value now comes from whether software has been actively used. Although AI has shifted bottlenecks from coding to design and evaluation, he believes the core difficulty of software engineering remains, and he doubts a widespread threat to enterprise SaaS since companies generally prefer proven, professionally managed solutions over DIY vibecoded projects.

How I use LLMs as a staff engineer in 2026

In 2026, the author has significantly expanded his use of LLMs compared to 2025. The biggest shift is that AI agents are now reliable enough to produce entire pull requests in areas he’s familiar with, and he uses them constantly for bug investigation (correctly diagnosing ~80% of issues), codebase research, testing, and local setup tasks. He still writes his own PR descriptions and all public communications by hand, believing humans better convey core ideas and signal genuine review. He also avoids using LLMs for UI testing or writing blog posts, though he uses them for draft feedback. His core job — shipping projects, exercising judgment, and navigating politics — remains unchanged, but agents have expanded his capacity to take on small tasks. He warns that many people either under-utilize agents (not delegating enough) or over-utilize them (trusting them with unreviewed sweeping changes), and finding the right balance remains key.

The bottleneck was never the code

The article argues that coding agents shift the bottleneck in software development from writing code to collaboration, decision-making, and context-sharing. While agents dramatically boost individual productivity, the real challenge for organizations is producing precise specifications and maintaining shared context — something humans acquire informally but agents require explicitly. The author emphasizes that focus (saying no to unnecessary features) and organizational coherence become more critical as code becomes cheaper to produce. Agents can help by reading exhaustively to extract implicit knowledge, but some tacit context remains unrecoverable. Ultimately, the companies that thrive will be those that treat coherence and context as maintainable artifacts, not just those with the best technical tools.

Agentic Coding is a Trap

The article argues that over-reliance on AI coding agents is a trap that erodes developers’ critical thinking and debugging skills while creating costly dependencies. It warns that “agentic coding” distances engineers from implementation, causing cognitive atrophy, vendor lock-in, unpredictable token costs, and fragile systems that must manage AI’s non-determinism. Junior and senior developers alike lose the friction essential for deep learning and ownership. Drawing parallels to past tech shifts, the author insists the risk is real and immediate. He advocates using LLMs as secondary aids for planning and research—not as autonomous orchestrators—while keeping hands-on coding central, ensuring competence, quality, and long-term value over short-term speed.

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

🚀 VS Code Insiders Podcast

Episode 22: Agent-First Development Workflows in VS Code with Brigit Murtaugh

Repositories

pydantic/httpx2 (BSD-3-Clause)

With HTTPX itself seeing limited activity recently, Pydantic is picking up stewardship under the HTTPX2 name so that users have a reliably maintained path forward - including timely security updates for a library that sits in the critical path of so many production systems.

MinishLab/semble (MIT)

Semble is a code search library built for agents. It returns the exact code snippets they need instantly, using ~98% fewer tokens than grep+read. Indexing and searching a full codebase end-to-end takes under a second, with ~200x faster indexing and ~10x faster queries than a code-specialized transformer, at 99% of its retrieval quality.

microsoft/Webwright (MIT)

Webwright gives LLM a terminal where it can launch multiple browser sessions to inspect the page and complete a web task. It captures and inspects page screenshots/states only when needed. It enforces each web task to be completed end-to-end within a re-runnable Python script, i.e. your web agent browsing history is a single code file. No multi-agent system, no graph engine, no plugin layer, no hidden orchestration — just a terminal, a browser, and a model.

As we wrap up this journey together, I want to take a moment to express my gratitude for your reading. If you’ve enjoyed what you just read and would like to help sustain this blog, consider starring this blog on github, it would be great motivation for me to keep updating the blogs!

Alright, that concludes the May Edition of “This Month for Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in June! 👋

This Month for Pythonistas - April 2026

Zeyang Lin — Thu, 30 Apr 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 4

Welcome back Pythonistas! This is the April 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts and community highlights.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

Reflecting on Five Years as the PSF’s First CPython Developer in Residence

The article reflects on Łukasz Langa’s nearly five-year tenure as the PSF’s first CPython Developer in Residence, highlighting contributions like transitioning to GitHub issues, automating the CLA process, introducing free threading, and modernizing the interactive shell. The role will continue with Meta’s sponsorship through mid-2027. The position has expanded from one to five full-time engineers, ensuring its stability. Łukasz expresses gratitude to the Steering Council and excitement about moving to Vancouver while joining Meta, emphasizing ongoing commitment to the Python community.

DjangoCon Europe 2026

DjangoCon Europe goes to Athens, Greece this year, from April 15th to 19th. More info can be found here.

Introducing GPT‑5.5

OpenAI released GPT-5.5 which excels in coding, knowledge work, scientific research and cybersecurity, matching GPT-5.4’s latency with stronger performance. It has higher token efficiency and stricter safeguards. Now available for Plus/Pro/Business/Enterprise users; API versions launch soon. GPT-5.5 Pro delivers better accuracy for complex tasks.

Introducing Claude Opus 4.7

Claude Opus 4.7, Anthropic’s latest model, is now generally available. It significantly advances Opus 4.6 in advanced software engineering, handling difficult coding tasks with greater autonomy, precision, and consistency. The model also features substantially improved vision, higher-resolution image understanding, and more creative, professional outputs. It demonstrates stronger reasoning, better instruction following, and enhanced multimodal capabilities. With safeguards for cybersecurity and expanded access across products and cloud platforms, Opus 4.7 aims to accelerate complex workflows while maintaining reliability and safety.

Qwen3.6-Plus: Towards Real World Agents

Qwen has launched Qwen3.6-Plus, a major upgrade featuring dramatically enhanced agentic coding capabilities and improved multimodal reasoning. The model now supports a 1M context window by default and excels in complex tasks like frontend development, terminal operations, and automated task execution. It demonstrates state-of-the-art performance across coding benchmarks (SWE-bench, Terminal-Bench 2.0), general agent tasks, and multimodal understanding (MMMU, document analysis, video reasoning).

GLM-5.1: Towards Long-Horizon Tasks

GLM-5.1 is Z.ai’s next-generation flagship model designed for agentic engineering tasks with significantly improved coding capabilities. It achieves state-of-the-art performance on SWE-Bench Pro and leads on NL2Repo and Terminal-Bench 2.0 benchmarks. Unlike previous models that plateau early, GLM-5.1 excels at long-horizon optimization, demonstrated by achieving 6× better results over 600 iterations on vector database optimization, sustaining 3.6× speedup over 1,000+ turns on ML workloads, and building a complete Linux desktop environment over 8 hours through continuous refinement.

Kimi K2.6: Advancing Open-Source Coding

Kimi K2.6 is an open-source model from Moonshot featuring advanced coding, long-horizon execution, and agent swarm capabilities. It demonstrates significant improvements over K2.5 in complex engineering tasks, autonomously handling multi-step workflows across programming languages like Rust, Go, and Python. The model excels at long-running tasks—such as optimizing financial engines and deploying models—with strong tool-calling accuracy (96.60%). K2.6 also enables coding-driven frontend design and full-stack development, while its Agent Swarm architecture scales to 300 sub-agents executing 4,000 coordinated steps. Used in proactive agents like OpenClaw and Hermes, it supports 24/7 autonomous operations and collaborative multi-agent systems through Claw Groups, achieving state-of-the-art performance on benchmarks like SWE-Bench and Terminal-Bench 2.0.

The next evolution of the Agents SDK

The article discusses the next evolution of OpenAI’s Agents SDK, introducing enhanced capabilities for building AI agents. The updated SDK enables developers to create agents that can inspect files, execute commands, edit code, and handle long-term tasks within controlled sandbox environments. Key features include configurable memory, sandbox-aware orchestration, filesystem tools, MCP integration for tool use, and native sandbox execution with providers like Blaxel and Daytona. The architecture separates harness from compute, supports durable execution through snapshotting, and provides standardized primitives for building reliable, scalable agent systems with improved security and performance.

New Versions

Python 3.15.0a8, 3.14.4 and 3.13.13 are out!

3.15.0 alpha 8 is expected to be the last alpha build before beta 1 comes out in May 2026. You can find the full release schedule of Python 3.15 here.

3.14.4 and 3.13.13 are bug fix releases for Python 3.14 and 3.13 respectively, both with binary as well as tarball distributions.

Tutorials

DeepLearning.ai’s Efficient Inference with SGLang: Text and Image Generation

In this course, you’ll build a clear mental model of how inference works (from input tokens to generated output) and learn why the memory bottleneck exists. From there, you’ll implement the KV cache from scratch to store and reuse intermediate attention values within a single request. Then you’ll go further with RadixAttention, SGLang’s approach to sharing KV cache across requests by identifying common prefixes using a radix tree. Finally, you’ll apply these same optimization principles to image generation using diffusion models.

DeepLearning.ai’s Spec-Driven Development with Coding Agents from Paul Everitt

In this course, you’ll write project constitutions, plan and validate features in iterative loops, and apply the same repeatable workflow to both fresh and legacy codebases. You’ll also see how specs preserve context across agent sessions, reduce cognitive debt, and improve intent fidelity, keeping your agent aligned with what you actually want.

DeepLearning.ai’s Building Multimodal Data Pipelines from Snowflake

Images, audio, and video make up a growing share of the data companies generate today, but most pipelines are still built for structured data alone. This course teaches you to build AI-powered pipelines that process multimodal data and turn it into LLM-ready text.

RealPython’s Variables in Python: Usage and Best Practices

In Python, “variables” are symbolic names that refer to objects or values stored in memory, created by assigning a value with the = operator. They are dynamically typed, so their type can change through reassignment, and naming follows rules like using letters, digits, and underscores but not starting with a digit, with snake_case preferred for readability. Variables can be used in expressions, as counters, accumulators, flags, loop variables, or data storage, and they exist in scopes (global, local, non-local, built-in) that determine accessibility. Python also supports type hints, multiple assignment, iterable unpacking, assignment expressions, and pattern matching for creating variables, while attributes in classes provide namespace-like behavior, and del can remove variables from scope.

Articles

Cutting Python Web App Memory Over 31%

The article from Michael Kennedy details how Michael Kennedy reduced his Python web app memory usage from 1,988 MB to 472 MB (over 31% reduction, saving 3.2 GB total) using five key techniques: migrating to Quart (async Flask) with a single Granian worker, replacing the MongoEngine ODM with a Raw+DataClass database pattern, isolating the search indexer into a subprocess (cutting it from 708 MB to 22 MB), moving heavy library imports like boto3 and pandas from global to local function-level imports, and shifting in-memory caches to disk-based caching using the diskcache library.

Python: introducing profiling-explorer

The author introduces profiling-explorer, a new Python tool for exploring profiling data from pstats files generated by Python’s built-in profilers. It provides a web-based interface with features like dark mode, sortable columns, search filtering, and navigation between callers and callees. The tool was motivated by the author’s optimization work where the command-line pstats interface felt clunky. The article also explains Python’s three profilers — profile (deprecated), profiling.tracing (cProfile), and the new sampling profiler Tachyon in Python 3.15 — and provides instructions for generating pstats files and using profiling-explorer to analyze them, sponsored by Rippling.

Django: fixing a memory “leak” from Python 3.14’s incremental garbage collection

The article details an out-of-memory error encountered when running Django migrations on Python 3.14, specifically on a resource-constrained Heroku server. Python 3.14 introduced incremental garbage collection to reduce pause times, but this algorithm struggled with Django’s cyclical objects, causing memory usage to spike beyond limits. The author implemented a workaround by extending Django’s migrate command to force full garbage collection after each migration using gc.collect(), which resolved the issue. Coincidentally, the Python core team announced they would revert incremental garbage collection in Python 3.14.5 due to widespread memory concerns, validating the problem and rendering the workaround temporary.

Using a `~/.pdbrc` file to customize the Python Debugger

The article explores customizing Python’s built-in debugger (pdb) via a .pdbrc configuration file. It details how to set up persistent aliases, command shortcuts, and environment adjustments to streamline debugging workflows. The author provides practical examples, such as defining custom commands and automating routine tasks, demonstrating how .pdbrc enhances productivity by reducing repetitive input. The piece also touches on best practices for organizing configurations and ensuring compatibility across different debugging sessions, making pdb more adaptable to individual developer preferences and complex project requirements.

Building a Python Library in 2026

This blog post provides a comprehensive guide to building Python libraries in 2026, emphasizing modern tools and best practices. The author recommends using uv from Astral as the central tool for project initialization, dependency management, building, and publishing. Key components include: a standard src layout, pyproject.toml metadata, linting/formatting with ruff, type checking with mypy (or alternatives), testing with pytest and coverage, CI enforcement via GitHub Actions, and pre-commit hooks. The author also explores publishing options beyond PyPI and examines real-world implementations from OpenAI and Polars, demonstrating how these tools streamline modern Python package development.

Why pylock.toml includes digital attestations

This blog post from Brett Cannon explains why pylock.toml includes digital attestations to enhance Python package security. Triggered by a recent PyPI project hack, the author highlights how trusted publishing allows continuous deployment systems to securely upload packages without exposing credentials. Digital attestations verify that a package genuinely originated from its expected CD system. When recorded in pylock.toml, publisher details for each package enable automated or manual verification to detect suspicious changes, such as missing or altered attestation data. Ultimately, the author recommends maintainers adopt trusted publishing with attestations, use lock files like pylock.toml, and regularly review attestation consistency to catch potential supply chain attacks.

Continual learning for AI agents

The blog post from Langchain explains that continual learning for AI agents can occur at three distinct layers: the model (weight updates using techniques like SFT or RL), the harness (optimizing the code and tools around the model), and the context (updating configuration, instructions, skills, or memory). While most discussions focus on model-level learning, the harness and context layers offer practical ways to improve agents over time. Traces — the full execution logs of agents — are central to all approaches, enabling analysis and improvement. The harness can be refined by reviewing traces to suggest code changes, while context can be updated at agent, user, or organization levels, either offline or in real-time. Tools like LangSmith and frameworks like Deep Agents support these patterns, allowing AI systems to continuously learn and adapt.

pixi: One Package Manager for Python and C/C++ Libraries

The article compares uv and pixi as Python package managers, explaining that while uv excels at fast dependency resolution and lockfiles for pure Python projects from PyPI, it cannot install compiled C/C++ system libraries like GDAL, requiring separate OS package managers. pixi solves this by managing both Python packages from PyPI and compiled libraries from conda-forge in a single tool, with automatic lockfiles, multi-platform support, built-in task running, and project-level environments. The author recommends using uv for simple Python projects and pixi when working with compiled dependencies, geospatial libraries, or needing unified package management across platforms.

Learning Rust Made Me a Better Python Developer

Learning Rust improved the author’s Python development by forcing explicit thinking about data ownership, error handling, and edge cases. Rust’s compiler enforces strict patterns that prevent common bugs: ownership rules stop unexpected mutations, Result types make failure explicit in return types, and exhaustive pattern matching ensures all cases are handled. Though Python’s type system can approximate these concepts, Rust’s compiler builds a disciplined reflex. The author now writes cleaner, more predictable Python — asking who owns data before mutating, modeling errors explicitly, and treating all possible states — even though Rust and Python serve different roles (performance vs. orchestration) and aren’t direct competitors.

What every dev should know about AI sandboxes

AI sandboxes are critical for safely running AI agents, protecting production systems from potentially harmful actions. The threat model has evolved: agents may confidently execute wrong instructions, not just malicious attacks. Isolation levels range from lightweight containers (fast but share kernel) to MicroVMs (hardware-level isolation but slower), gVisor (userspace kernel), OS-level primitives like Bubblewrap (zero overhead), and simulated environments. Trade-offs exist between speed and security. Vendors like E2B (Firecracker-based), Modal (gVisor), and Daytona (container-based) offer solutions. Building your own sandbox is discouraged unless it’s your core product, as managing security, observability, and lifecycle complexity distracts from primary goals.

Long-running Agents

Long-running agents are AI systems that maintain progress across hours, days, or weeks, overcoming the limitations of traditional chat-based agents that forget and fail over long tasks. They require solving three core problems: finite context windows, lack of persistent state, and unreliable self-verification. Leading approaches from Anthropic, Cursor, and Google converge on decoupling the model’s reasoning loop from execution sandboxes and durable session logs, while implementing patterns like checkpoint-and-resume, memory banks, and separate evaluators to ensure reliability. These systems enable economically feasible delegation of complex, multi-day work, though challenges remain around cost, security, alignment drift, and defining work that can survive autonomous execution.

Scaling Managed Agents: Decoupling the brain from the hands

Anthropic’s Managed Agents service decouples the “brain” (Claude and its harness) from the “hands” (execution sandboxes) and the “session” (event log) through stable, general-purpose interfaces. This architecture — inspired by operating system virtualization — addresses the fragility of earlier monolithic designs where components were tightly coupled in single containers. By treating each component as interchangeable “cattle” rather than precious “pets”, the system gains reliability, security (credentials are isolated from execution), and performance (reducing time-to-first-token by 60-90%). The meta-harness design is opinionated about interfaces but unopinionated about specific implementations, allowing it to evolve alongside model improvements.

Multi-agent coordination patterns: Five approaches and when to use them

The Claude blog outlines five multi-agent coordination patterns for teams building AI systems. The generator-verifier pattern loops output between generation and validation for quality-critical work. Orchestrator-subagent uses a lead agent to delegate clear, bounded subtasks. Agent teams employ persistent workers for independent, long-running parallel work. Message bus routes events through publish-subscribe for evolving pipelines. Shared state lets agents collaborate through a common knowledge store. The authors recommend starting with orchestrator-subagent as the simplest pattern, then evolving as needs clarify, emphasizing that patterns are building blocks often combined in production systems rather than mutually exclusive choices.

Managing context in long-run agentic applications

The article discusses managing context in long-running agentic systems, focusing on Slack’s approach to maintaining coherence across multi-agent investigations. It addresses challenges posed by limited language model context windows and proposes three complementary channels: the Director’s Journal for structured memory, the Critic’s Review for credibility-scored findings, and the Critic’s Timeline for consolidated, evidence-based chronology. These mechanisms enable specialized agent roles while preserving alignment and creativity, allowing systems to operate effectively over extended interactions. The solution emphasizes online summarization rather than accumulating message history, ensuring scalability and trustworthiness.

Components of A Coding Agent

This article by Sebastian Raschka explains the core components of coding agents (like Claude Code and Codex CLI) that make LLMs more effective for programming tasks. The author describes six key building blocks:

(1) Live Repo Context - understanding the project structure and environment; (2) Prompt Shape and Cache Reuse - efficiently packaging and caching stable information; (3) Tool Access and Use - enabling structured tool calls with validation; (4) Minimizing Context Bloat - compressing and deduplicating history; (5) Structured Session Memory - maintaining both full transcripts and distilled working memory; and (6) Delegation with Subagents - splitting tasks into bounded subtasks.

The article emphasizes that the harness layer often matters as much as the underlying model itself, explaining why coding agents feel significantly more capable than the same models in plain chat interfaces.

All your agents are going async

The post argues that AI agents are shifting from synchronous chat to asynchronous, background workflows, breaking HTTP request‑response transport. Async agents need durable state and push-based delivery because they outlive connections, push unprompted updates, switch devices, and serve multiple users. Current solutions like Anthropic Channels, Cloudflare Sessions, and OpenClaw’s WhatsApp model address state or delivery but often rely on polling or custom backends. The author advocates a durable, realtime session layer—bi‑directional, multi‑device, and resilient—that separates conversation state from transport, enabling reliable async collaboration between humans and agents.

Why we’re rethinking cache for the AI era

Cloudflare’s analysis reveals that 32% of network traffic originates from automated sources, including AI bots and crawlers. Unlike human users, AI traffic exhibits high-volume sequential requests targeting long-tail content across websites, significantly raising cache miss rates and straining CDN infrastructure. This has caused real-world impacts like Wikipedia’s 50% surge in bandwidth usage and service slowdowns across platforms like SourceHut and Fedora. Current cache algorithms such as LRU struggle under AI’s constant scanning behavior. Cloudflare proposes AI-aware solutions including alternative cache replacement algorithms (SEIVE, S3FIFO), machine learning-based caching, and ultimately a separate cache layer dedicated to AI traffic to maintain performance for human users.

Your harness, your memory

Agent harnesses — the systems that coordinate LLMs with tools and data — are becoming the standard way to build AI agents, and they are fundamentally tied to memory management. Using closed, proprietary harnesses means surrendering control of your agent’s memory to third parties, which creates significant lock-in. Memory is what allows agents to learn from interactions and deliver personalized experiences, making it a crucial competitive advantage. The article argues that both memory and harnesses should be open and independently owned to maintain flexibility and avoid platform dependency. To address this, the author introduces Deep Agents as an open-source, model-agnostic framework that gives developers full control over their agents’ memory storage and retrieval.

Oh Memories, Where’d You Go

Engram is Weaviate’s memory product (in private preview) designed to store context beyond what fits in Claude Code’s built-in MEMORY.md file (~200 lines). The author tested it by building an MCP server integration but initially found Claude ignored Engram because MEMORY.md loads with zero latency. The solution involved categorizing memories (communication-style, domain-context, tool-preferences, workflow) and integrating at specific session lifecycle points. Testing showed Engram excelled at “decision archaeology” (30% faster with reasoning chains recalled), but failed on planning tasks where Claude defaults to forward-moving. Key improvements needed include fire-and-forget saves, automatic memory capture pipelines, and deterministic retrieval hooks at session start.

The Spec Layer

The blog advocates for spec-driven development (SDD) to constrain AI agents’ execution freedom and prevent “wrong kind of correct” mistakes. Unlike humans, agents make locally valid errors like disabling tests or reusing existing patterns. Written specs provide durable intent that narrows choices at implementation time. Historical protocol examples (RFCs for IP, HTTP, TLS, HTML) demonstrate how specs enable multiple implementations over decades. The ideal spec should be declarative, layered, and cheap to revise, with mechanical enforcement moved to lint, schemas, and tests. The goal is a narrow interface between human intent and machine execution: smaller specs, harder checks, and less guessing.

I Still Prefer MCP Over Skills

The author argues that MCP (Model Context Protocol) is superior to Skills for connecting LLMs to external services because it’s an API abstraction where the LLM only needs to know the “what”, not the “how”. MCP offers zero-install remote usage, seamless auto-updates, proper authentication handling, true portability, sandboxing, and smart tool discovery. Skills, however, require CLI installation, can’t work in many environments like ChatGPT or Perplexity, create deployment and secret management nightmares, and bloat the context window. He concludes that MCP should be the standard for connecting to services, while Skills should only be used for teaching LLMs knowledge about existing tools or workflows — not as replacements for actual service connectors.

The Beginning of Programming as We’ll Know It

The article discusses the impact of AI coding assistants on the programming profession. While AI tools like Claude and Codex can now complete significant coding tasks in minutes, the author argues that human programmers remain essential during this transitional period. Humans bring unique qualities like taste, wisdom, and caution that AI lacks. The author emphasizes that AI-generated code must be reviewed and corrected by humans before it can be considered real work. Despite AI’s impressive capabilities, there’s a “reality distortion field” around AI outputs that can mislead developers. The conclusion is that programmers who embrace AI while maintaining skepticism and human oversight will be better equipped than ever, while those who refuse these tools will fall behind.

The Cult Of Vibe Coding Is Insane

This article criticizes the “vibe coding” trend where developers avoid examining underlying code, instead relying solely on vague AI conversations. After Claude’s source code leak revealed poor quality, the author argues that “pure vibe coding” is a myth — human contributions still occur through language and infrastructure frameworks. Bad software isn’t inevitable with AI; it’s a conscious choice. The author explains that AI excels at cleaning up technical debt when given proper guidance through collaborative dialogue, and developers should actively steer AI toward high-quality outcomes rather than accepting mediocrity. The core message: poor software quality is a decision, not a necessity.

Claude Is Not Your Architect. Stop Letting It Pretend.

The article warns against using AI like Claude as a software architect, arguing that while AI agents are excellent implementers, they cannot make real architectural decisions. AI is “pathologically agreeable” — always validating ideas enthusiastically without the crucial ability to say “no” or push back on complexity. It produces generic “Jenga tower” architectures that look sound but aren’t tailored to specific teams, constraints, or production realities. The real danger is that engineers are reduced to implementing AI-designed tickets, while accountability vanishes — when systems fail, humans stay up debugging decisions they didn’t make. The solution: humans must design, AI must implement.

Podcasts

🥝 core.py

Episode 29: Is CPython developed with AI now?

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🚀 VS Code Insiders Podcast

Episode 21: Inside The Agent Loop with Pierce Boggan

Repositories

NousResearch/hermes-agent (MIT)

The self-improving AI agent built by Nous Research. It’s the only agent with a built-in learning loop — it creates skills from experience, improves them during use, nudges itself to persist knowledge, searches its own past conversations, and builds a deepening model of who you are across sessions.

dropseed/plain (BSD-3)

Forked from Django, plain is an opinionated Python web framework which is ready for the AI Agent age. You can visit their official website for more information.

smelloscope/smello (MIT)

Capture outgoing HTTP requests from your Python code and browse them in a local web dashboard — including gRPC calls made by Google Cloud libraries.

Alright, that concludes the April Edition of “This Month for Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in May! 👋

This Month for Pythonistas - March 2026

Zeyang Lin — Tue, 31 Mar 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 3

Welcome back Pythonistas! This is the March 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts and community highlights.

Time flies! It has been a whole year since the first issue of “This Month for Pythonistas”. I’m excited to kick off another year of informative content and community engagement, and I can’t wait to see what you have in store for this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

OpenAI acquires Astral

OpenAI has announced its acquisition of Astral, the company behind popular Python developer tools including uv, Ruff, and ty. This deal aims to integrate these widely-used open source tools into OpenAI’s Codex ecosystem, which has grown to over 2 million weekly active users with 3x user growth and 5x increased usage since the start of the year. The acquisition will help expand Codex beyond simple code generation to participate in the entire software development workflow, from planning changes to maintaining software over time. The deal is subject to regulatory approval, and Astral’s team will join OpenAI’s Codex team after closing.

Astral founder Charlie Marsh announced that this acquisition will accelerate their mission to make programming more productive by combining Astral’s tooling expertise with AI innovation at the frontier of software development. OpenAI will continue supporting Astral’s open source tools after the deal closes, maintaining their commitment to building in the open alongside the Python community for broader ecosystem impact.

PyCon US 2026 Schedule Revealed

The PyCon US 2026 schedule has been released! Besides, the keynote speakers are announced: Lin Qiao, Pablo Galindo Salgado, amanda casari, Rachell Calhoun, as well as Tim Schilling.

The Python Insider Blog Has Moved!

The Python Insider official blog has moved from Blogger to blog.python.org, with all 307 past posts migrated and old URLs auto-redirecting; RSS readers will update automatically without action. Shifting to Markdown/Git pull requests lowered contribution barriers vs. the prior Blogger/Google account setup. New site features include filtered/paginated posts, author/tag pages, Ctrl+K search, dark mode, and static Astro hosting.

Guido van Rossum Interviews Thomas Wouters

This interview with Thomas Wouters, conducted by Guido van Rossum, chronicles Wouters’ journey from discovering Python via LambdaMOO in the late 1990s to becoming a core Python developer. He contributed augmented assignment operators (+=) and range literals (PEP 203), while participating in pivotal discussions about backward compatibility and nested scopes that led to future imports. Wouters reflects on the friendly Python community during the Usenet era, mentioning key figures like Tim Peters, Fredrik Lundh, and Jeremy Hilton. He also discusses the founding of the Python Software Foundation in 2001 and the challenges of organizing the first PyCon, highlighting how Python evolved from individual use to corporate deployment while maintaining its collaborative spirit.

Guido van Rossum Interviews Brett Cannon

This interview with Python core developer Brett Cannon, also conducted by Guido van Rossum, explores Brett’s journey into the Python community. In 2000, philosophy student Brett discovered Python at UC Berkeley while seeking an object-oriented language for a CS course. After reading the tutorial and an O’Reilly book, he fell in love with the language. During a gap year before grad school, he submitted a pure-Python strptime implementation to python-dev, which led to his first core contribution in 2002. He volunteered to write the python-dev summaries, became PSF member, gained commit rights in April 2003, and was involved in major projects like importlib and Python 3 (PEP 3000/3100). Brett reflects on the early community’s small, passionate nature, the transition from volunteer contributions to paid maintainers, and Python’s evolution through CVS, Subversion, Mercurial, and Git on SourceForge to GitHub.

Py AI Conference

Hosted on March 10th at San Francisco, California, this one-day conference is for Python teams shipping AI to production. Keynote speakers include Guido van Rossum, Sebastián Ramírez (FastAPI) and more.

Gemini 3.1 Flash-Lite: Built for intelligence at scale

Google has launched Gemini 3.1 Flash-Lite, its fastest and most cost-efficient AI model in the Gemini 3 series. Priced at just $0.25 per million input tokens and $1.50 per million output tokens, it delivers 2.5x faster response times and 45% higher output speed compared to its predecessor 2.5 Flash. The model achieves a 1432 Elo score and outperforms competitors on reasoning and multimodal benchmarks. Available via Google AI Studio and Vertex AI, Flash-Lite is optimized for high-volume workloads like translation, content moderation, and UI generation, with adaptive thinking levels for developer control.

Gemini Embedding 2: Our first natively multimodal embedding model

Google has also released Gemini Embedding 2, its first natively multimodal embedding model that maps text, images, videos, audio, and documents into a single unified embedding space, supporting over 100 languages. The model handles up to 8192 text tokens, 6 images, 120 seconds of video, native audio without transcription, and PDFs up to 6 pages per request. It supports interleaved multi-modal inputs in a single request and uses Matryoshka Representation Learning to offer flexible output dimensions (3072, 1536, or 768).

Introducing GPT‑5.4

OpenAI has launched GPT-5.4, their most powerful and efficient frontier model for professional workloads. The model combines advanced reasoning, programming, and agent capabilities with native computer use functionality and 1M token context support. GPT-5.4 introduces “Thinking mode” in ChatGPT, providing transparent reasoning plans, and features improved web search, tool search, and higher accuracy with 33% reduced hallucinations. Performance benchmarks show significant improvements across knowledge work, coding, and complex tasks.

MiniMax M2.7: Early Echoes of Self-Evolution

MiniMax M2.7 is a groundbreaking AI model that deeply participates in its own self-evolution, capable of building complex agent harnesses and completing elaborate productivity tasks. It excels in professional software engineering with 56.22% accuracy on SWE-Pro benchmark, demonstrates top-tier office software capabilities with the highest ELO score among open-source models (1495 on GDPval-AA), and maintains 97% skill adherence across 40 complex skills. The model shows enhanced character consistency and emotional intelligence for entertainment applications.

New Versions

Python 3.15.0 alpha 7

This is the seventh and possiblly the second last alpha release for 3.15 series before the scheduled beta phase begins in May 2026.

Besides, Python 3.12.13, 3.11.15 and 3.10.20, the security bugfix releases for 3.12, 3.11 and 3.10 respectively with only tarball distributions, are also available.

Tutorials

DeepLearning.ai’s Agent Memory: Building Memory-Aware Agents from Oracle

You’ll design a complete memory system that stores and retrieves different memory types, scales tool access using semantic search, and builds write-back loops that allow agents to update their own memory autonomously. By the end, you’ll have assembled a fully stateful Memory Aware Agent that loads prior context at startup, assembles relevant context, state, tools, and outputs and improves across sessions.

Real Python’s Pydantic AI: Build Type-Safe LLM Agents in Python

Pydantic AI is a Python framework for building type-safe LLM agents that return validated, structured outputs using Pydantic models. It eliminates the need for error-prone string parsing by defining schemas with type hints, letting the framework handle validation automatically. The framework uses @agent.tool decorator to register Python functions that LLMs can invoke based on user queries and docstrings. It also supports dependency injection with deps_type for type-safe runtime context like database connections without using global state.

Articles

Thoughts on OpenAI acquiring Astral and uv/ruff/ty

uv stands out as the most impactful tool with 126 million+ monthly downloads, becoming essential for Python environment management. The author discusses potential risks of a major company owning critical infrastructure, parallels to Anthropic’s Bun acquisition, and concerns about OpenAI’s limited track record maintaining open source projects. The author notes that due to permissive licensing, forking remains a viable exit strategy if maintenance deteriorates after the transition.

Python 3.15’s JIT is now back on track

Python 3.15’s JIT compiler has achieved its performance goals ahead of schedule, delivering 11-12% speed improvements on macOS AArch64 and 5-6% on x86_64 Linux compared to the interpreter. The article recounts how the original JIT in Python 3.13 and 3.14 was often slower than the interpreter, and funding cuts to the Faster CPython team made the project’s future uncertain. The author attributes the revival to community-led development, lucky technical choices like trace recording with dual dispatch and reference count elimination, and strong teamwork. Daily performance tracking and breaking complex problems into manageable tasks helped attract contributors, transforming the JIT from an opaque project into something newcomers could contribute to.

The Optimization Ladder

This article presents a comprehensive benchmark of Python optimization techniques, demonstrating a spectrum of approaches from simple to complex. CPython’s dynamic design makes it fundamentally slow (177-875x slower than C for compute benchmarks). The “optimization ladder” shows increasing speedups at higher effort levels: upgrading Python (1.4x), alternative runtimes like PyPy/GraalPy (6-66x), compilation tools like Mypyc (2.4-14x), Numba (56-135x), Cython (99-124x), and JAX (up to 1,633x). For real-world JSON processing, gains were more modest. The author emphasizes that the choice depends on your specific problem - Python as an orchestration layer with NumPy can achieve near-compiled speeds, while pure compute loops benefit most from aggressive optimization.

When to make a class in Python

This article outlines when to use Python classes. Most developers first use classes when required by frameworks like Django for database models. Classes excel at bundling related data and functionality — for example, replacing functions passing a shared server object with an IMAPChecker class. They also clarify data, like shutil’s terminal size class over a bare tuple. While much Python code avoids custom classes, classes improve readability by grouping state and methods together.

Invent your own comprehensions in Python

This article explains how to create “custom comprehensions” in Python using generator expressions. While Python has built-in comprehensions for lists, sets, and dictionaries, it lacks tuple, frozenset, and other specialized collection comprehensions.

The solution is to pass generator expressions to callable functions or classes that accept iterables. For example:

tuple(n**2 for n numbers) acts as a “tuple comprehension”
frozenset(w.strip(...) for w in words) acts as a “frozenset comprehension”
Counter(w.strip(...) for w in words) acts as a “Counter comprehension”

Generator expressions also work with reducer functions like sum(), any(), all(), and join(). The key insight is that any iterable-accepting callable can essentially become a custom comprehension tool.

Fire and forget (or never) with Python’s asyncio

The article discusses a critical issue with fire-and-forget tasks in Python’s asyncio. Starting in Python 3.12, asyncio.create_task() can silently garbage collect tasks before they execute because the event loop only maintains weak references. This means tasks that aren’t explicitly referenced may never run, creating subtle bugs. The solution is to store task references in a set and register a done_callback to clean them up after completion. This non-obvious workaround violates Python’s “one obvious way” principle but prevents tasks from disappearing mid-execution, ensuring reliable background task execution in async applications.

Reinventing Python’s AsyncIO

The author discusses reinventing Python’s asyncio due to its complexity and limitations around the GIL. After discovering tinyio — a simple event loop implementation — the author created TonIO, a new async runtime built in Rust centered on two simple primitives: Event and Waiter. Unlike asyncio, TonIO leverages free-threaded Python to run code across multiple threads without worrying about the main thread. Benchmarks show TonIO is 2-3.5x faster than asyncio for both computation and I/O operations. The author advocates for “reinventing the wheel” to truly understand low-level concepts, encouraging developers to build rather than just ship code.

What Python’s asyncio primitives get wrong about shared state

This blog post discusses problems with Python’s asyncio primitives (Event, Condition, Queue) when coordinating concurrent tasks around shared state.

The author explains that while asyncio.Condition seems to solve the problem of waiting for specific states, it suffers from a lost update bug under real concurrency: when a state changes rapidly (e.g., “closing” → “closed” in the same event loop tick), consumers wake up and check against the current value, missing the intermediate state they were waiting for.

The solution is per-consumer queues: instead of waking consumers and asking “is the current state what you want?”, buffer every state transition into each consumer’s queue. This ensures no intermediate states are missed.

The author provides a ValueWatcher class implementation (about 300 lines) with features like thread safety, timeouts, predicate-based matching, and atomic registration.

CLI subcommands with lazy imports

Brett Cannon’s article discusses using lazy imports (PEP 810 in Python 3.15) with CLI subcommands to improve startup performance. While lazy imports allow importing only needed modules per subcommand, traditional argparse patterns break this: storing lazy imports in dicts or as default function arguments triggers their reification, defeating the purpose. Solutions include using a match statement instead of a dict for dispatching, or wrapping lazy imports in lambdas to add an indirection layer. Both approaches prevent accidental reification while keeping code organized.

The Story of Python’s Lazy Imports: Why It Took Three Years and Two Attempts

This blog post tells the story of Python’s lazy imports feature, which took three years and two attempts to implement. The problem: running simple commands like mytool --help forces Python to load heavy libraries (PyTorch, NumPy, pandas) even when unnecessary. Companies like Meta and Hudson River Trading built their own forks with lazy imports, achieving 50-70% startup time improvements.

PEP 690 (2022) proposed a global -L flag to make all imports lazy by default, but the Steering Council rejected it, fearing it would create “two Pythons” and break the ecosystem.

At the 2023 Language Summit, Thomas Wouters was the only attendee who said he could “never” support lazy imports.

PEP 810 (2025) changed the design: instead of a global flag, it uses an opt-in lazy import keyword with proxy objects—avoiding changes to Python’s internal dictionary structure. Wouters himself became a co-author. The Steering Council unanimously accepted PEP 810 in November 2025, and it will arrive in Python 3.15.

Python Type Checker Comparison: Typing Spec Conformance

This article compares Python type checkers’ conformance to the typing specification, presenting test pass rates: Pyright (97.8%), Zuban (96.4%), Pyrefly (87.8%), mypy (58.3%), and ty (53.2%). It explains that conformance measures how closely checkers follow formal typing rules, with lower conformance forcing developers to work around limitations. However, the article notes conformance has limitations — it doesn’t assess type inference, narrowing behavior, performance, IDE integration, error clarity, or third-party package support. The conclusion recommends considering multiple factors beyond conformance when selecting a type checker, as overall developer experience depends on many dimensions.

Rewriting a 20-year-old Python library

The author recounts rewriting akismet, a 20-year-old Python library for spam filtering originally created by Michael Foord. The rewrite, completed in 2024-2025, separated the library into SyncClient and AsyncClient classes to support both synchronous and asynchronous operations, introduced an enum-based response system to handle “blatant” spam detection, and switched from requests to httpx for better async support and testability. The codebase was reorganized into multiple files, added comprehensive type hints, pytest fixtures, and test client variants. The author dedicated the work to Foord, who passed away in 2025, hoping to honor his legacy by ensuring the library remains maintainable for decades to come.

Replacing tox with UV

This blog post discusses replacing tox with UV for testing Python libraries across multiple Python versions. The author was upgrading libraries to Python 3.10+ and needed to run tests on different Python versions. While tox and nox are common tools for this, UV offers a more convenient single-tool solution.

Key features of UV for testing include:

Using uv run -p 3.10 pytest to test with specific Python versions
Specifying extras and dependency groups with --extra and --group flags
Overriding package versions with --with or -w options
Using --isolated to avoid contaminating the development virtual environment
Running tests in parallel with commands like parallel "uv run -p {} --isolated pytest" ::: 3.{10..14}

The author concludes that while tox remains useful, UV provides a faster, more streamlined approach for debugging version incompatibilities.

Unit testing your code’s performance, part 2: Catching speed changes

This article presents a technique for using unit tests to detect performance changes in code by measuring CPU instruction counts rather than elapsed time. The method involves using libraries like py-perf-event or Valgrind’s Cachegrind to count instructions during test runs. If the instruction count changes beyond a threshold, the test fails, providing early warning to developers before committing changes. The approach requires reducing noise through consistent environments, hash seeds, and disabling ASLR. While not a replacement for benchmarks, these tests offer immediate feedback during development. The technique has caveats: it may not work in virtualized CI, and results vary across hardware, but can help catch accidental performance regressions early.

Defense in Depth: A Practical Guide to Python Supply Chain Security

The article offers a practical guide to Python supply chain security, advocating defense in depth. Key strategies: use ruff security linting; pin dependencies with cryptographic hashes via uv; run pip-audit in CI; generate SBOMs with CycloneDX; adopt Trusted Publishing (OIDC) instead of long-lived tokens; audit GitHub Actions with zizmor; consider delayed ingestion for internal mirrors. It covers threats like dependency confusion, account takeover, and malicious packages, and provides a phased implementation roadmap. The core message: no single control is perfect, so layer multiple defenses.

Building shared coding guidelines for AI (and people too)

This StackOverflow blog post explains how to create effective coding guidelines for AI coding agents. Unlike human developers who absorb tacit knowledge, AI agents lack contextual understanding and require explicit, unambiguous instructions. Guidelines should cover naming conventions, formatting, error handling, and comments using clear, simple language without idioms. Providing both correct and incorrect code examples, plus a “gold standard” reference file, helps agents learn patterns. Errors should be treated as feedback to iteratively improve guidelines collaboratively with the team. Ultimately, these guidelines should be stored in agent configuration files while still using traditional tools like linters to catch basics.

When AI Writes the World’s Software, Who Verifies It?

This post notes AI is already writing a growing share of global software — 25-30% of Google/Microsoft’s new code, plus a 100k-line C compiler in two weeks. It warns unvetted AI code risks widespread security flaws and supply chain attacks, with current poor software quality costing the US $2.4T annually. The solution is formal mathematical proofs, and Lean has emerged as the leading platform to guarantee correct, secure AI-generated code.

AI Coding is Gambling

AI coding generates impressive initial results but behaves like gambling — pulling a slot machine hoping for a jackpot. While AI makes codebase changes trivial and reduces cognitive burden, it often produces plausible yet flawed solutions. The process is addictive but lacks the traditional coding rewards: deep thinking, clever problem-solving, and the satisfaction of making things work. AI offloads the mental work that nurtures the soul, transforming coding from creative problem-solving into mindless slot-pulling, leaving developers to merely clean up poorly implemented code rather than genuinely building solutions.

Is AI Killing Software Engineering Jobs?

The article argues that AI is not responsible for declining software engineering jobs. The downturn actually began in May 2022, before ChatGPT’s launch, triggered by rising interest rates following pandemic-era cheap money. Hiring has been recovering (~5% growth recently). The apparent job shortage stems from reduced employee churn and fear-driven narratives, not AI replacing engineers. Despite layoffs, the developer population continued growing. Businesses claiming to replace engineers with AI still hire them. The author criticizes fear-mongering “AI thought leaders” and predicts demand will recover as it has after previous bust cycles, addressing the temporary pain of those who lost jobs.

Reports of code’s death are greatly exaggerated

The article argues against the notion that AI will eliminate coding. The author explains that English specifications feel precise until complexity reveals their vagueness, using examples like collaborative text editors. The solution to managing complexity is abstraction—compressing many details into single concepts. Even with AGI, code will remain essential because human thinking requires precise abstractions to master complexity, similar to how ChatGPT hasn’t replaced novelists. AI will actually enhance coding by helping create better abstractions and higher-quality code, not make it obsolete. The article concludes that code is just getting started, not dying.

Read Less, Steer More

The blog post argues that with AI coding agents, developers should focus less on reading generated code and more on steering the AI precisely. The author recommends treating AI as a fast typist executing your specifications rather than as an autonomous teammate, demanding justification when something doesn’t make sense. “Vibe coding” is a trap — instead, maintain active involvement to reduce cognitive burden. Beginners should practice without “accept edits” to train intuition, while recognizing that genuine discovery still requires human-speed creation and cannot be rushed. The key mindset shift: don’t accommodate the AI’s output; steer it to match your exact vision.

“Design Me a Highly Resilient Database”

This article argues that there’s no such thing as a “highly resilient database” in the abstract — it always depends on the specific use case. The author recounts failing a job interview by asking clarifying questions about data types, query patterns, and failure modes instead of simply naming a database like “Cassandra”. The piece explains that different databases serve different purposes: PostgreSQL provides ACID compliance essential for financial transactions, Cassandra handles write-heavy workloads with eventual consistency for IoT data, and Redis works best for caching. The author emphasizes that the CAP theorem forces tradeoffs between consistency and availability, and choosing the wrong database — like eventual consistency for ledgers — can lead to audit failures and regulatory issues. The right approach starts with questions, not product names.

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

#218: Why Python developers are learning Rust

🚀 VS Code Insiders Podcast

Episode 20: Autopilot Mode with Justin Chen

Repositories

agentscope-ai/ReMe (Apache-2.0)

ReMe is a memory management framework designed for AI agents, providing both file-based and vector-based memory systems.

It tackles two core problems of agent memory: limited context window (early information is truncated or lost in long conversations) and stateless sessions (new sessions cannot inherit history and always start from scratch).

alibaba/OpenSandbox (Apache-2.0)

OpenSandbox is a general-purpose sandbox platform for AI applications, offering multi-language SDKs, unified sandbox APIs, and Docker/Kubernetes runtimes for scenarios like Coding Agents, GUI Agents, Agent Evaluation, AI Code Execution, and RL Training.

NVIDIA/OpenShell (Apache-2.0)

OpenShell is the safe, private runtime for autonomous AI agents. It provides sandboxed execution environments that protect your data, credentials, and infrastructure — governed by declarative YAML policies that prevent unauthorized file access, data exfiltration, and uncontrolled network activity.

Gen-Verse/OpenClaw-RL (Apache-2.0)

OpenClaw-RL is a fully asynchronous reinforcement learning framework that turns everyday conversations into training signals for personalized AI agents, and supports training general agents with large-scale environment parallelization.

Alright, that concludes the March Edition of “This Month for Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you next month! 👋

This Month for Pythonistas - February 2026

Zeyang Lin — Sat, 28 Feb 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 2

Welcome back Pythonistas! This is the February 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts and community highlights.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

Python Unplugged

Python Unplugged is a free online conference bringing together the leading voices of the Python community. It would be live on Youtube on 4th of March, 2026 from 11:00 am to 6:30 pm CET.

Introducing Claude Opus 4.6

Anthropic has released Claude Opus 4.6, its “most capable” AI model yet. The new flagship significantly improves coding, planning, and agentic task execution, with enhanced ability to work autonomously on complex, long-running projects. It features a 1M token context window (first for Opus-class) and achieves state-of-the-art results on key benchmarks including Terminal-Bench 2.0, Humanity’s Last Exam, and GDPval-AA, outperforming competitors by wide margins. Despite intelligence gains, Opus 4.6 maintains excellent safety with low misaligned behavior and minimal over-refusals. The model is available now on claude.ai, the API, and major cloud platforms with new developer features including adaptive thinking, effort controls, and context compaction.

Introducing GPT-5.3-Codex

OpenAI has launched GPT-5.3-Codex, a highly capable agentic coding model that is 25% faster and sets new industry records on coding benchmarks like SWE-Bench Pro (56.8%) and Terminal-Bench 2.0 (77.3%). It can build complex games and handle professional tasks beyond coding, including data analysis and presentations. Notably, this model helped accelerate its own development. GPT-5.3-Codex offers real-time interactive steering, strong cybersecurity capabilities classified as “High capability,” and is available through paid ChatGPT plans and API access.

GLM-5: From Vibe Coding to Agentic Engineering

GLM-5 is Z.ai’s latest model targeting complex systems engineering and long-horizon agentic tasks. It scales up to 744B parameters (40B active) with 28.5T tokens of training data, integrating DeepSeek Sparse Attention for efficiency. A novel asynchronous RL infrastructure called “slime” improves training. GLM-5 achieves best-in-class performance among open-source models on reasoning, coding, and agent benchmarks, ranking #1 on Vending Bench 2 with a $4,432 final balance. It’s open-sourced under MIT license, available via API, and supports local deployment with compatibility for Claude Code and OpenClaw.

MiniMax M2.5: Built for Real-World Productivity.

MiniMax introduces M2.5, a new AI model extensively trained with reinforcement learning in complex real-world environments. It achieves state-of-the-art performance in coding (80.2% SWE-Bench Verified), tool use, search (76.3% BrowseComp), and office work. M2.5 completes tasks 37% faster than its predecessor M2.1, matching Claude Opus 4.6’s speed while costing only 10% as much. At $1 per hour (100 tokens/sec) or $0.30 (50 tokens/sec), it offers extremely cost-effective AI for productivity applications.

Nano Banana 2: Combining Pro capabilities with lightning-fast speed

Google DeepMind has launched Nano Banana 2, a new AI image generation model that combines the advanced capabilities of Nano Banana Pro with the speed of Gemini Flash. The model offers enhanced features including advanced world knowledge with real-time information, subject consistency for up to five characters and 14 objects, precise instruction following, production-ready specs (512px to 4K), and improved visual fidelity.

Hello Entire World

Entire, a new company backed by a $60 million seed round, aiming to create the world’s next developer platform for AI‑driven coding agents. Their first product, the Entire CLI, introduces “Checkpoints” – a Git‑compatible primitive that automatically records an agent’s full context (prompts, transcripts, token usage, tool calls, etc.) with each commit, storing it on a dedicated branch. This makes AI‑generated code traceable, easier to review, and reusable across sessions, while reducing token waste and supporting multiple agents. The CLI is open‑source, supports Claude Code and Gemini now, and will expand to other models. The vision is an AI‑native, open, and scalable software‑development lifecycle.

New Versions

Python 3.15.0 alpha 6

This sixth alpha build of 3.15 arrives in the middle of February.

Additionally, Python 3.14.3 and 3.13.12 (both being bugfix releases) are also available.

transformers 5

Transformers v5 was released as a major upgrade, with support for over 400 model architectures (up from ~40 in v4) and 750,000+ model checkpoints. Key improvements include 20-30% faster inference, a new modular architecture that simplifies adding models, streamlined tokenizers and image processors, and native quantization support. It also introduces a built-in HTTP server (transformers serve) for easy deployment. The library now integrates tightly with popular inference engines like vLLM and SGLang, and supports GGUF files for local execution. Existing v4 checkpoints remain compatible, though PyTorch-only support means Flax/TensorFlow have been deprecated.

isort 8

isort 8 drops support of Python 3.9, and fixes a number of issues.

Tutorials

Deeplearning.ai’s Agent Skills with Anthropic by Anthropic

In this course, you’ll learn how skills work, explore best practices for creating them, and build skills for different use cases. You’ll see skills in action across Claude.ai, Claude Code, the Claude API, and the Claude Agent SDK, and learn how to combine them with MCP and subagents for complex workflows.

Deeplearning.ai’s A2A: The Agent2Agent Protocol by Google Cloud and IBM

In this course, you’ll build a healthcare multi-agent system with three specialized agents using different frameworks. You’ll wrap each agent in an A2A server, build A2A clients to communicate with them, and orchestrate them into sequential and hierarchical workflows. You’ll see how A2A complements MCP: while MCP connects agents to external data systems, A2A enables agents to collaborate with each other.

Articles

PEP 814 – Add frozendict built-in type

PEP 814 is accepted. This PEP proposes adding an immutable frozendict built-in type to Python 3.15. It implements the Mapping protocol, preserves insertion order, and is hashable when all keys/values are hashable. Unlike MappingProxyType, it’s truly immutable and hashable, making it safe for use with @functools.lru_cache() and as dictionary keys. It supports union operators (|, |=) and can replace mutable dicts in stdlib constants for safety. Unlike collections.frozenmap, frozendict maintains insertion order and provides O(1) lookups. The implementation shares code with dict but is not a subclass to prevent mutation via dict methods.

From Python 3.3 to today: ending 15 years of subprocess polling

For 15 years, Python’s subprocess module and psutil used busy-loop polling to wait for processes, causing unnecessary CPU usage and latency. The author replaced this with event-driven approaches: using pidfd_open() with poll() on Linux (kernel 5.3+), kqueue() on BSD/macOS, and existing mechanisms on Windows. This eliminates busy-looping - the process blocks until the kernel signals process termination or timeout. Measurements show dramatic reduction in CPU context switches (from 258+ to just 2). The improvement first landed in psutil and was contributed upstream to CPython.

Speeding up Pillow’s open and save

This blog post by Hugo van Kemenade details performance improvements to Pillow’s image open/save operations using Python 3.15’s Tachyon profiler. Previously, Pillow would import many image format plugins unnecessarily even when only one format was needed. A new file extension-to-plugin mapping enables lazy loading, only importing relevant plugins. Results: PNG opening 2.6x faster, WebP opening 14x faster, PNG saving 2.2x faster, and WebP saving 7.9x faster. These optimizations will be included in Pillow 12.2.0, making image processing more efficient especially for command-line tools.

Is it a class or a function?

The article explains that in Python both classes and functions are callables — they’re invoked with parentheses and may return a value. Examples: print and sum are built‑in functions; str, list, bool, enumerate, and type are classes that behave like functions, returning new objects when called. Because the user‑facing syntax is the same, Python programmers often call any callable a “function” even when it’s technically a class. This fuzzy terminology fits Python’s duck‑typing philosophy: what matters is the object’s behavior (being callable), not its exact implementation.

Anatomy of a Python Function

The article explains the terminology for a Python function’s parts. The function body is everything indented after the definition. The function definition runs from def to the end of the body, though many think it ends at the colon. The first line (from def to the colon) is called the function header by the author; others may call it a declaration, but not a signature. A signature consists only of the parameter list and return annotation, as defined by PEP 362. Clear naming matters for type‑checking and communication.

switch-case in Python? It’s not match-case!

Python lacks a traditional switch-case statement, though it has match-case from Python 3.10. However, match-case is designed for structural pattern-matching (matching iterables, dictionaries, objects, and nested patterns), not simple value-based switching. For basic switch-case needs, if-elif chains are more readable and require less indentation. When mapping input values to outputs, dictionaries are typically the best alternative. The article advises using match-case only for advanced pattern-matching scenarios, not as a direct replacement for switch statements found in other languages. Most Python programmers are unfamiliar with match-case, so simpler constructs are usually preferable.

Making Pyrefly Diagnostics 18x Faster

Pyrefly achieved an 18x performance improvement in diagnostic updates through two key optimizations. The first was implementing fine-grained dependency tracking, which reduces module invalidation from 2000+ to just 100+ by tracking exactly which types are used rather than all imports. The second was streaming diagnostics directly to the IDE as files are rechecked, rather than waiting for the entire recheck process to complete. These changes reduce diagnostic update time from ~3.6 seconds to under 200ms on an M4 Macbook Pro, making type errors refresh instantly after saving a file. The team continues prioritizing speed, memory efficiency, and functionality as they approach the v1 release.

Better Python tests with `inline-snapshot`

The article introduces inline-snapshot, a Python testing library that automatically manages test data. Instead of manually writing assertions for complex data structures, developers use snapshot() placeholders that get auto-populated when running pytest --inline-snapshot=fix. This eliminates tedious maintenance when data changes. The library pairs well with dirty-equals to handle dynamic fields like timestamps via IsInt() and IsNow(). Snapshots can even be nested within complex structures. The underlying executing library enables automatic source code updates by inspecting Python AST.

Django: profile memory usage with `Memray`

This blog post explains how to profile and reduce memory usage in Django projects using Memray, a memory profiler from Bloomberg. The author demonstrates profiling the Django “check” command, generating flame graphs to visualize allocations, and identifying that importing numpy.random consumed 5.7MB (23% of peak 25.2MB). By replacing numpy.random with Python’s built-in random.shuffle(), memory usage dropped 22% to 19.4MB. The post also offers solutions like deferred imports, lazy imports (upcoming in Python 3.15), and provides a Zsh one-liner for faster iteration. The key takeaway: Memray helps pinpoint and eliminate unnecessary memory bloat in Django applications.

Implementing local-first agentic AI: A practical guide

This article provides a practical guide for implementing local-first agentic AI using Small Language Models (SLMs) in privacy-sensitive environments. It presents an enterprise use case: an HR triage system that processes sensitive employee reports. The system uses a three-stage pipeline: intent detection (classifying issues like harassment or burnout), planning (creating remediation steps), and tool execution (performing actions like opening HR cases). Key models include sentence-transformers/all-MiniLM-L6-v2 (~90M), Phi-3-mini (~3.8B), and Function Gemma (~2B). The “Local First, Cloud Last” architecture runs on modest hardware without GPUs, offering privacy, cost efficiency, and auditability while avoiding cloud latency and compliance risks. SLMs require precise prompt engineering but enable easy local testing without paid tokens, making them ideal for enterprise workloads with strict data locality constraints.

Agent Trace: Capturing the Context Graph of Code

Agent Trace is an open, vendor-neutral specification for recording AI contributions alongside human authorship in version-controlled codebases. It solves the modern problem of context loss by linking each code change to its originating conversation and context, rather than just storing line differences like traditional git. This enables powerful engineering management tools (blaming AI vs humans, PR breakdowns, dashboards) and significantly improves AI agent performance by making context retrievable, reducing wasted inference time. The spec represents a shift where context—not lines of code—becomes the precious resource in the AI era.

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

VS Code Insiders Podcast

Episode 19: Subagents: Parallel Execution and Context Isolation

Repositories

volcengine/OpenViking (Apache 2.0)

OpenViking is a context database designed specifically for AI Agents which unifies the management of context (memory, resources, and skills) that Agents need through a file system paradigm, enabling hierarchical context delivery and self-evolving.

NevaMind-AI/memU (Apache 2.0)

memU is a memory framework built for 24/7 proactive agents. It is designed for long-running use and greatly reduces the LLM token cost of keeping agents always online, making always-on, evolving agents practical in production systems. memU continuously captures and understands user intent. Even without a command, the agent can tell what you are about to do and act on it by itself.

Have time for some fun?

Kena: Scars of Kosmora is announced during State of Play

Kena: Scars of Kosmora, the second chapter of Kena’s adventure, brings our Spirit Guide to the mysterious realm of Kosmora, an island “full of buried secrets from a tragic past”. You can watch the announcement trailer here.

It is expected to launch on PlayStation 5 and PC later this year.

Alright, that concludes the February Edition of “This Month for Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in March! 👋

This Month for Pythonistas - January 2026

Zeyang Lin — Sat, 31 Jan 2026 04:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 1

Welcome back Pythonistas and Happy New Year 🎉! This is the first issue of 2026, and I’m excited to kick off another year of “This Month for Pythonistas” with curated Python news, tutorials, articles, podcasts and community highlights. And as a “special” issue it would cover also retrospectives of 2025 and expectations for 2026.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

EuroPython 2026 Location Revealed

EuroPython 2026 will take place in Kraków, Poland from 13th to 19th July, 2026. The CFP (Call for Proposals) is open now until 15th of February. This is also the 25th anniversary of EuroPython. Learn more here.

Anthropic invests $1.5 million in the Python Software Foundation and open source security

Anthropic invests $1.5M over two years in the Python Software Foundation (PSF). Funds will enhance Python ecosystem security (e.g., automated PyPI package reviews to ward off supply-chain attacks) and sustain the PSF’s core work supporting CPython, its global community and infrastructure.

2026 Python Developers Survey

This is the nineth official Developer Survey by PSF, in partnership with JetBrains. Completing the survey contributes to understanding the state of Python development and the Python community.

PEP 686 - Make UTF-8 mode default

PEP 686 is Final. Starting from Python 3.15, Python will use UTF-8 mode by default in text encoding. This change represents a significant step toward modernizing Python’s text handling while maintaining backward compatibility through opt-out mechanisms and warnings.

New Versions

Python 3.15.0 alpha 5

Here comes the fifth of ~~seven~~ eight planned alpha releases of Python 3.15, just a couple of days after alpha 4 was released.

Pandas 3.0.0

Pandas 3.0.0 is the long-awaited major release which brings significant improvements to pandas, but also features some potentially breaking changes. The release notes can be found here.

FastMCP 3.0.0 beta 1

FastMCP 3.0 introduces a redesigned framework for building Model Context Protocol servers. Built around three primitives — Components, Providers, and Transforms — it transforms from simple tool servers into dynamic “Context Applications” that intelligently manage information for AI agents. Read more at What’s New in FastMCP 3.0.

Tutorials

Deeplearning.ai’s Document AI: From OCR to Agentic Doc Extraction from LandingAI

This course shows you how to build agentic workflows that process documents the way humans do: breaking them into parts, examining each piece carefully, and extracting information through multiple iterations.

Deeplearning.ai’s Gemini CLI: Code & Create with an Open-Source Agent from Google

In this course, you’ll apply Gemini CLI to software development and creative tasks by building features for an AI conference. You’ll develop a website session catalog, create a data dashboard combining local and cloud data sources, and generate social media content from recordings. You’ll master context management, integrate MCP servers, and orchestrate across multiple services with Gemini CLI extensions.

RealPython’s How to Build a Personal Python Learning Roadmap

This tutorial will help you craft a personal Python learning roadmap so you can track your progress and stay accountable to your goals and timeline.

Articles

Python Numbers Every Programmer Should Know

This article from Michael Kennedy outlines key Python performance and memory metrics for developers. Latency benchmarks include fast attribute reads (14 ns), dict lookups (22 ns), and FastAPI’s quick JSON responses (8.63 µs). Memory usage notes are striking: small ints/floats take 28/24 bytes, empty Python processes use ~15.7 MB, and slots-class instances (5 attributes) consume 212 bytes (vs 694 bytes for regular classes). Other stats highlight list append speed (28.7 ns) and SQLite query efficiency. These numbers aid in optimizing performance-sensitive algorithms.

Recent optimizations in Python’s Reference Counting

The article discusses Python 3.14+ optimizations for reference counting in CPython. It introduces a new bytecode instruction LOAD_FAST_BORROW that avoids incrementing reference counts when loading local variables in hot loops, reducing memory management overhead. This optimization uses static lifetime analysis to ensure safety - borrowed references must be consumed within one code block, used for simple operations, and the source value can’t change during execution. The optimization is similar to Rust’s lifetime analysis and immutable borrowing concept. Additionally, there are ongoing efforts to eliminate redundant reference counting in JIT compiled code, though this is experimental and disabled by default.

The Hidden Cost of Python Dictionaries (And 3 Safer Alternatives)

This article explains the hidden dangers of Python dictionaries: typos in keys cause silent bugs, and type errors lead to data corruption. It presents three safer alternatives with increasing protection:

NamedTuple – Fixed structure with IDE autocomplete; immutable
dataclass – Mutable fields, safe defaults, custom validation via __post_init__
Pydantic – Runtime type enforcement, automatic type coercion, built-in constraints

The author recommends using dicts for quick prototyping and Pydantic for production code where safety matters.

Implicit string concatenation

Python automatically concatenates string literals placed next to each other without any operator - called “implicit string concatenation”. This feature is mainly used for breaking long strings across multiple lines using parentheses for implicit line continuation. However, it can cause bugs when commas are accidentally omitted in lists or function calls. The article recommends avoiding this feature in favor of explicit concatenation with + or using multiline strings with textwrap.dedent(), and suggests using linters to prevent accidental usage.

What async really means for your python web app?

Python async web benchmarks reveal surprising results: synchronous Django with database connection pooling consistently outperforms async alternatives. Testing static content, database reads, and contentious writes shows that FastAPI excels only when it’s the sole bottleneck. For typical web services that directly access databases, the database — not the web service — is usually the bottleneck. Async Django shows 10x slower performance than sync Django for static content, while database pooling eliminates sync latency issues without code changes. The article concludes that for most services directly connecting to databases, optimized sync configurations deliver better performance than async alternatives.

Asyncio is neither fast nor slow

This article critiques misleading benchmarks comparing Python’s async vs sync web frameworks. The author discovered that performance discrepancies often stem from implementation bugs (like SQLAlchemy fetching all results) rather than asyncio itself. After proper configuration, async and sync perform similarly.

The key takeaway: asyncio’s advantage isn’t speed but resource efficiency — achieving comparable performance without extra threads/processes. The author advises against taking benchmarks at face value and encourages testing for your specific requirements. Performance depends more on implementation details and connection pools than the async/sync paradigm itself.

How to Type Hint a Decorator in Python

This article explains how to properly type hint Python decorators. Using TypeVar causes mypy errors. Instead, use ParamSpec with TypeVar to capture generic parameter and return types. For Python 3.12+, PEP 695 offers simplified syntax using square brackets (e.g., def info[**P, R]) to implicitly declare ParameterSpec. Both approaches maintain type safety for decorated functions while preserving their original signatures.

Static Protocols in Python: Behaviour Over Inheritance

This article explains static protocols in Python - a way to check object behavior rather than inheritance. Protocols enable structural typing where objects are validated by having required methods/attributes, not by class hierarchy. The author contrasts this with traditional “goose typing” using isinstance(), showing how protocols reduce coupling and enable static type checking. A real-world ML example demonstrates using a Predictable protocol for models with predict_top_k methods. Static protocols (Python 3.8+) provide type safety while maintaining flexibility, allowing different coding styles to work together without complex inheritance trees. They catch errors at development time rather than runtime.

Unit testing your code’s performance, part 1: Big-O scaling

This article explains how to unit test your Python code’s performance by testing Big-O scalability. It introduces the bigO library to empirically determine and test algorithm complexity. The author demonstrates how to track function performance, generate reports showing time/memory bounds (like O(n) or O(n²)), and write automated tests that fail when scalability changes. This approach catches critical performance regressions where algorithms become less efficient, which is especially important for processing large datasets. The method is presented as a starting point for performance testing, with plans to cover additional efficiency testing in future articles.

How we made Python’s packaging library 3x faster

Python’s packaging library was optimized to achieve 3x faster performance in version 26.0rc1. Key improvements include: Version construction became 2x faster, SpecifierSet operations up to 3x faster, and some operations up to 5x faster. Optimizations involved removing redundant NamedTuple structures, eliminating duplicate Version creation, using faster regex patterns, replacing singledispatch with if statements, and implementing better caching. The team used Python 3.15’s statistical profiler and PyPI metadata to measure performance. These changes significantly speed up dependency resolution for tools like pip, which creates millions of Version objects during package installation.

WebAssembly as a Python extension platform

This blog post explores using WebAssembly (Wasm) as a Python extension platform. The author discusses two main use cases: (1) replacing Python functions with faster C-compiled-to-Wasm code for 10x performance improvements, and (2) embedding secure crypto libraries like Monocypher in Python applications. Key challenges include handling pointers as unsigned integers, managing memory allocation between host and guest, and working around wasmtime-py limitations.

The author provides detailed examples showing how to create Python bindings for Wasm modules while avoiding common pitfalls like negative pointer arithmetic. Despite rough edges like large binary sizes and API instability, this approach enables distributing architecture-independent Python packages without requiring native toolchains.

The Emperor Has No Clothes: How to Code Claude Code in 200 Lines of Code

This article reveals that AI coding assistants like Claude Code aren’t magic — they’re built on a simple 200-line Python architecture. The core concept is a conversation loop between an LLM and a toolbox of three essential functions: read files, list files, and edit files.

The process works by having the LLM decide when to use tools, sending structured tool calls, executing them locally, and feeding results back. The LLM never directly touches the filesystem—it just requests actions that your code performs.

While production tools add features like better error handling, streaming, and more tools, the fundamental architecture remains this simple request-execute-respond cycle. The author demonstrates how anyone can build a functional coding agent using this straightforward pattern, proving that sophisticated AI coding tools are built on surprisingly simple foundations.

The Future of Software Development is Software Developers

The article argues that despite claims that AI (especially LLMs) will replace software developers, history shows new technologies don’t reduce programming needs but increase demand. The hard part of programming is translating human ambiguity into precise code, which AI struggles with. LLMs often slow development and produce unreliable code. While AI may assist in prototyping or inline completion, developers will remain essential. The current AI hype will likely fade, and businesses should hire and train developers now. The future will see AI as a tool, not a replacement, with more demand for skilled programmers.

Agent-native Architectures

This guide outlines a revolutionary approach to software development where AI agents are first-class citizens, not just add-ons. The core principle: build applications where features aren’t code you write, but outcomes you describe that agents achieve using tools in loops.

Five key principles govern this architecture: Parity (agents can do everything users can via UI), Granularity (atomic tools enable flexible composition), Composability (new features emerge from prompt combinations), Emergent capability (agents accomplish unanticipated tasks), and Improvement over time (apps get better through context and prompt refinement).

The approach shifts from traditional feature-by-feature development to creating a capable foundation and observing what users request, then formalizing patterns. Files serve as the universal interface due to their transparency and agent-friendliness.

This architecture enables applications that are simple to start but endlessly powerful, discover latent user demand organically, and improve without code updates. The ultimate test: can your agent accomplish domain-specific outcomes you never explicitly built features for?

Demystifying evals for AI agents

This article explains how to effectively evaluate AI agents, whose autonomy and flexibility make them harder to assess than traditional models. Good evaluations prevent reactive debugging cycles by catching issues before they affect users.

The authors outline a comprehensive evaluation framework with key components: tasks (individual tests), trials (multiple attempts), graders (scoring logic), transcripts (complete interaction records), and evaluation harnesses (infrastructure). They recommend combining three grader types: code-based (fast, objective), model-based (flexible, nuanced), and human (gold standard validation).

Different agent types require tailored approaches: coding agents use unit tests and static analysis; conversational agents need multidimensional scoring including interaction quality; research agents require groundedness and coverage checks; computer use agents need outcome verification in real environments.

The article provides a practical roadmap: start early with 20-50 real-world tasks, build robust harnesses with stable environments, design thoughtful graders, and maintain long-term through transcript review. When combined with production monitoring, A/B testing, and user feedback, evaluations create a comprehensive quality system that accelerates development rather than slowing it down.

How to build self-improving coding agents

Part 1

To build self-improving coding agents without changing model weights, the author proposes modifying the agent’s environment using two key levers: AGENTS.md as repository memory and skills as reusable playbooks.

AGENTS.md helps agents navigate codebases quickly through code maps and encodes repo-specific corrections and norms, preventing repeated mistakes. When agents discover mismatches or receive user feedback, they should update the documentation automatically, creating a durable feedback loop. This operational approach reduces repetitive guidance and makes agents improvement without constant babysitting.

Part 2

The second explores “skills” for coding agents—reusable prompt folders (SKILL.md + assets) that streamline repetitive tasks. Skills explicitly define when to use them, steps to follow, and expected outputs. Examples include GitHub debugging, release announcements, ML model reports, and domain-specific troubleshooting. Skills evolve through iteration and feedback, making them easier to refine than starting from scratch. While distribution is less mature than MCP servers, tools like OpenSkills now help with installation and updates.

Part 3

Part 3 combines repo memory (AGENTS.md) and skills into a practice with a maturity model: ad hoc prompting → repo-local memory → global personal skills → shared team skills. Watch agent traces to identify patterns—repo-specific go into AGENTS.md, reusable workflows become skills. Markdown becomes executable when agents turn instructions into tool calls. The key distinction: AGENTS.md for how a repo works; skills for repeatable, on-demand procedures. The meta skill is metacognition—watching yourself work to systematize repeated tasks. Coding agents are evolving beyond coding tools into general-purpose teammates across all intellectual work.

AI writes code faster. Your job is still to prove it works.

AI accelerates coding but shifts the burden from writing to proving code works. By 2026, 30% of senior developers ship mostly AI-generated code, which has 75% more logic errors. Solo developers rely on automated testing as safety nets, while teams use human review for security, context, and accountability. AI generates 45% of code with security flaws and increases PR volume by 18%, creating review bottlenecks. The new “PR contract” requires authors to provide evidence of working code through tests and manual verification. AI serves as first-pass reviewer, but human judgment remains essential for quality control and responsibility.

AI Makes Exploration Cheap, Not Decisions Easy

AI makes exploration cheaper, not decisions easier. The key insight is that AI accelerates the exploration phase of creative work, allowing designers and developers to try more options in less time, but it doesn’t eliminate the need for human judgment.

Great work requires “wasted work” - trying multiple approaches that don’t work to discover what does. AI compresses this process from days/weeks to hours, enabling rapid prototyping and experimentation. However, AI cannot make final decisions because it lacks context about users, brand, constraints, and past experiences.

The human role shifts to Director-Curator-Craftsman: setting vision, selecting from AI-generated abundance, and applying taste and judgment. The real benefit is faster learning - each failed attempt teaches something valuable about the problem.

The trap is letting AI make decisions for you. Instead, use AI to multiply exploration, then apply critical thinking to choose the best option. Your value lies in knowing what should get built and why, not in the mechanical production work.

Top Python libraries of 2025

Tryolabs’ 11th 2025 top Python libraries list balances LLM-focused tools and broader ecosystem innovations (performance, security, dev experience). It includes 10 top general picks (e.g., Rust-powered ty type checker) and 10 AI/ML/Data tools, plus runners-up for each category to reflect real-world AI system building.

PyPI in 2025: A Year in Review

The PyPI 2025 Year in Review highlights major growth and security improvements. Key statistics: over 3.9 million new files, 130,000 new projects, 1.92 exabytes transferred. Security enhancements included improved 2FA (52% of active users), trusted publishing (50,000+ projects), email verification, phishing protection, and zipfile security. Organizations grew to 7,742 created with 9,059 projects managed. The team processed 2,000+ malware reports (66% resolved in 4 hours), handled 2,221 account recoveries, and resolved 500+ name retention requests. New features included project archiving, new Terms of Service, and enhanced incident reporting transparency.

2025: The year in LLMs

2025 was a transformative year for LLMs, with key trends including “reasoning” as a dominant feature—models like OpenAI’s o3 and o4-mini excelled in multi-step problem-solving and tool integration. Agents emerged critical, particularly coding agents (e.g., Claude Code, Codex CLI) handling asynchronous tasks, generating $1B in run-rate revenue. Chinese open-weight models (GLM-4.7, Qwen3) outperformed competitors, ranking highly. Prompt-driven image editing tools (GPT-4o, Google’s Nano Banana) drove viral adoption. Meta’s Llama 4 underperformed, and long tasks advanced, with models completing hours-long assignments. Agents streamlined search, and async coding tools became mainstream. Leadership shifted, with OpenAI and Google innovating, while Chinese models challenged Western dominance.

Five Takes to End 2025

Parker Ortolani’s year-end tech analysis covers five key takes:

OpenAI risks distraction by over-productizing instead of focusing on core AI models;
Google’s dominance is resurgent with successful AI initiatives;
departing Apple designer Alan Dye deserves more credit for his influential 12-year tenure;
software-on-demand through AI coding tools is disrupting traditional app development;
while Apple delivered excellent hardware in 2025, they must launch a spectacular AI Siri in 2026 after delays.

Software Engineering in 2026

The article explores how 2025’s AI coding advances will reshape software engineering in 2026. LLM tools have significantly reduced the marginal cost of producing quality code, shifting bottlenecks elsewhere. Key changes expected: infrastructure abstractions become more valuable, CI infrastructure needs higher quality, human-guided abstractions grow crucial for preventing technical debt, code review must evolve to focus on high-impact decisions, and project timeline estimates will increase in variance. While building code becomes cheaper, operating systems and high-value projects remain less LLM-amenable, requiring deeper human expertise.

17 predictions for AI in 2026

This article presents 17 AI predictions from experts with confidence scores, focusing on technology advancement and economic impact. Key predictions include Big Tech exceeding $500B in capital expenditures, OpenAI/Anthropic hitting 2026 revenue goals ($30B/$15B), context windows stabilizing around 1M tokens, and US GDP growth remaining under 3.5%.

Other notable predictions include Tesla offering driverless taxi service, Chinese companies potentially surpassing Waymo’s robotaxi fleet, and AI avoiding major catastrophes.

Overall, the authors expect steady AI improvement but modest real-world economic impacts, dismissing both AI bubble fears and rapid “fast takeoff” scenarios, instead predicting gradual integration across industries.

Podcasts

🥝 core.py

Episode 28: 2025 In Review

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

Episode 18: Orchestrating Multiple Agents in VS Code with Ben & Peng

Repositories

adamchainz/tprof (MIT)

tprof is a targeting profiler for Python 3.12+ that only measures the time spent in specified target functions. You can use it to measure your program before and after an optimization to see if it made any difference, with a quick report on the command line.

Alright, that concludes the January Edition of “This Month for Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in February! 👋

This Month for Pythonistas - December 2025

Zeyang Lin — Wed, 31 Dec 2025 08:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2025 12

Welcome back Pythonistas! It’s the final month of 2025 (happy holidays!), and we have a lot to catch up on before the new year rings in.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

Investing in the Python ecosystem

Vercel has announced a significant expansion into the Python ecosystem by hiring the team behind Gel Data, led by renowned Python core developer Yury Selivanov and contributor Elvis Pranskevichus. Known for creating high-performance tools like uvloop and asyncpg, this team will spearhead Vercel’s efforts to bring world-class Python support to its AI Cloud.

This move marks a strategic shift for Vercel beyond its JavaScript and TypeScript roots, aiming to make Python deployment as seamless and fast as its existing frontend workflows. As part of this initiative, Vercel plans to improve Python framework support and actively contribute to the open-source tools the community relies on.

To demonstrate its commitment, Vercel is investing directly in the Python community through several initiatives:

Becoming a Maintaining-level sponsor of the Python Software Foundation (PSF).
Sponsoring core developer Serhiy Storchaka for a full year to support his work on the interpreter and standard library.
Funding key conferences, local meetups, and a planned hackathon.

Regarding the acquisition, Vercel clarified that the Gel Data platform itself will wind down by January 31, 2026, though its open-source components will remain available. The deal is focused strictly on acquiring Python expertise rather than entering the database market; Vercel intends to continue partnering with existing database providers via its marketplace.

Why developers still flock to Python: Guido van Rossum on readability, AI, and the future of programming

Despite TypeScript recently overtaking Python in GitHub popularity, Python creator Guido van Rossum remains optimistic about his language’s future. In this interview, he attributes Python’s enduring success —- including a 49% year-over-year growth —- to its core philosophy of readability and developer friendliness.

Guido highlights Python’s critical role in the AI boom, driven by a massive ecosystem (NumPy, PyTorch) rather than just syntax. He argues against enforcing strict typing for AI’s sake, believing tools should adapt to humans. Ultimately, Python’s accessibility to non-CS backgrounds and commitment to backward compatibility ensure it remains a foundational tool for the next generation of developers.

The Rise and Rise of FastAPI

Sebastián Ramirez, the creator behind FastAPI, talks about his background, motivation, inspiration, and surprise at the meteoric rise of his open source project in this short documentary produced by CultRepo.

AWS re:Invent 2025

Nova 2: Lite, Pro, Sonic and Omni, all with multi-modal capabilities
Nova Forge: blend proprietary data with Amazon Nova-curated training data and host custom models securely on AWS.
Kiro Powers:
strands-agents: TypeScript variant now in preview
Frontier agents: autonomous, scalable agents which can work for hours or days without intervention
AWS Lambda durable functions: build resilient multi-step applications and AI workflows that can execute for up to one year
AWS Transform custom: AI-powered custom modernization for code, APIs, etc.

Introducing GPT-5.2

OpenAI introduced GPT-5.2, their “most powerful” model series designed for professional knowledge work and persistent agents. The model significantly enhances capabilities in spreadsheet creation, presentation design, coding, image recognition, long-context understanding, and complex multi-step projects.

Key benchmarks show substantial improvements: GDPval knowledge work tasks at 70.9% (vs. 38.8% for GPT-5), SWE-Bench Pro software engineering at 55.6%, GPQA Diamond scientific questions at 92.4%, and near-perfect long-context reasoning (100% accuracy on 4-needle MRCR tests up to 256k tokens). Visual understanding and tool calling also saw major advances.

Three variants are available: GPT-5.2 Instant for daily tasks, Thinking for complex work, and Pro for highest-difficulty problems. The models are rolling out to paid ChatGPT users and available via API. Safety improvements include better responses to sensitive topics like mental health. Early partners like Notion, Box, Shopify, and Databricks report strong performance in real-world applications.

Gemini 3 Flash: frontier intelligence built for speed

Google introduced Gemini 3 Flash, a high-speed AI model in Gemini 3 family designed to deliver “frontier intelligence” with industry-leading efficiency. It combines Gemini 3 Pro-grade reasoning with Flash-level latency, significantly outperforming the 2.5 series. On benchmarks like GPQA Diamond, it achieves a 90.4% score while remaining 3x faster and more cost-effective ($0.50/1M input tokens) than previous models.

Key Features and Capabilities:

Agentic Workflows: Optimized for the new Google Antigravity platform, it excels at complex coding and agentic tasks, scoring 78% on coding evaluations.
Real-Time Multimodal Reasoning: It supports near-instant interactions, such as live sketching assistance, golf swing analysis, and “voice-to-app” creation without manual coding.
Ecosystem Integration: It is now the default model for the Gemini app and AI Mode in Search, providing more nuanced and visual responses globally.

Donating the Model Context Protocol and establishing the Agentic AI Foundation

Anthropic has donated its Model Context Protocol (MCP) to the newly established Agentic AI Foundation (AAIF), a directive fund under the Linux Foundation.

The AAIF was co-founded by Anthropic, Block, and OpenAI, with support from industry leaders like Google, Microsoft, and AWS. Its mission is to ensure the development of agentic AI remains transparent, collaborative, and in the public interest through shared open standards.

Key details include:

MCP’s Role: Launched a year ago, MCP serves as a universal open standard for connecting AI applications to external systems. It has already seen massive adoption, with over 10,000 active servers and support from major platforms.
Strategic Donation: By transferring MCP to the AAIF, Anthropic aims to maintain the protocol as a neutral, vendor-agnostic, and community-driven standard, preventing any single company from controlling the ecosystem.
Future Growth: MCP will be a founding project of the AAIF alongside Block’s “goose” and OpenAI’s “AGENTS.md.” Anthropic remains connected to the project and will continue to contribute to its development.

Cloudflare outage on December 5, 2025

On December 5, 2025, Cloudflare experienced a 25-minute service outage (08:47–09:12 UTC) affecting approximately 28% of its HTTP traffic. The incident resulted in widespread HTTP 500 errors but was not caused by a cyberattack.

The outage was triggered during an update intended to mitigate a critical React vulnerability (CVE-2025-55182). While attempting to disable an internal testing tool via a global configuration change, engineers inadvertently activated a dormant bug in Cloudflare’s Lua-based rules engine. A “killswitch” applied to a specific rule type (action “execute”) caused the code to attempt to access a non-existent object, resulting in a runtime error.

This error impacted customers using Cloudflare’s legacy FL1 proxy with Managed Rulesets. The outage ended once the configuration change was reverted. Cloudflare has apologized and is prioritizing resiliency measures, such as “fail-open” error handling and safer configuration rollout mechanisms, to prevent recurrence.

New Versions

Python 3.15.0 alpha 3

Here comes the third of seven planned alpha releases of Python 3.15.

Additionally, Python 3.14.2 and 3.13.11 (yet another two expedited releases) are also available.

Django 6.0

The highlights of this major release include: Template Partials, Background Tasks, Content Security Policy (CSP), Modernized Email API, and more. The full release notes can be found here. Read on and you can find articles down below that highlight this release.

ty 0.0.8

ty，the extremely fast Python type checker and language server from astral.sh, has reached its beta phase. Both the CLI and the VSCode extension are now updated.

Tutorials

deeplearning.ai’s Building Coding Agents with Tool Execution from E2B

In this course, you’ll build agents that write and execute code to accomplish tasks, going far beyond predefined function calls. Instead of limiting your agent to a fixed set of tools, you’ll let it access Python’s entire ecosystem, and write multi-step code sequences. Plus, you’ll learn to run this generated code safely in sandboxed cloud environments, protecting your systems from potentially harmful operations.

deeplearning.ai’s Nvidia’s NeMo Agent Toolkit: Making Agents Reliable

Nvidia’s open-source NeMo Agent Toolkit (NAT) provides the building blocks you need to harden your agents for production, whether built in raw Python, LangGraph, CrewAI, or any other framework.

RealPython’s How to Build the Python Skills That Get You Hired

This tutorial provides a strategic approach to building Python skills for career success. It outlines a three-step framework:

Step 1: Identify Skills Employers Value Research job listings to find recurring patterns. Common requirements include Python fundamentals, Git, unit testing, debugging, and increasingly familiarity with AI coding tools (GitHub Copilot, Claude Code, etc.). Different paths exist: web development (Flask/Django), data science (NumPy, pandas), or machine learning (PyTorch).

Step 2: Map Your Learning Path Create a skill roadmap worksheet tracking your current proficiency (1-5 scale), job relevance, and specific next actions. Use SMART criteria—make goals Specific, Measurable, Achievable, Relevant, and Time-bound. Prioritize high-impact, high-urgency skills first.

Step 3: Build Sustainable Practice Design weekly practice sessions (distributed learning works better than marathon sessions). Build complete projects demonstrating skills, practice coding challenges for interviews, and learn to use AI tools effectively. Focus on demonstrating judgment when reviewing AI-generated code.

Articles

PEP 810 - Explicit lazy imports

PEP 810 is accepted. It introduces syntax for explicit lazy imports in Python, allowing developers to defer module loading until the imported names are first used. This PEP is now targeted for Python 3.15.

Eventual Rust in CPython

Core Python developers Emma Smith and Kirill Podoprigora proposed integrating Rust into CPython, initially for optional modules but eventually as a build requirement. They cited benefits like memory safety and attracting new contributors, a sentiment supported by Guido van Rossum.

However, the proposal faced pushback regarding increased build complexity, potential community friction similar to “Rust for Linux”, and difficulties for niche architectures like those supported by Gentoo. Consequently, the authors scaled back the plan, indefinitely postponing mandatory adoption. They will focus instead on a gradual introduction via optional extension modules to build infrastructure and experience first.

Module compression overview

This article from Rodrigo Girão Serrão teaches Python 3.14’s new compression package, covering 5 modules: bz2, gzip, lzma, zlib, and zstd. It explains basic compression/decompression, file operations, and incremental processing. The modules offer simple compress/decompress functions plus advanced options. Zstd is new to Python 3.14 and shows superior compression ratios.

Generalising `itertools.pairwise`

This article explains Python’s itertools.pairwise, a tool for creating overlapping pairs of consecutive elements from an iterable. While often implemented with slicing, the post suggests a more robust approach using collections.deque.

The main focus is generalizing this to nwise, which generates tuples of n consecutive items. Three implementations are demonstrated:

Adapting the deque method with maxlen=n.
Using itertools.tee to manage multiple independent iterators.
A recursive solution that builds nwise by repeatedly applying pairwise.

Django: what’s new in 6.0

Django 6.0 introduces four headline features to the web framework:

Template Partials: A new tag allows defining and reusing named fragments within templates, greatly simplifying workflows with libraries like HTMX.
Tasks Framework: A standard, built-in API for defining and enqueuing background tasks, designed to work with various task runner backends (like django-tasks).
Content Security Policy: Native middleware and settings for CSP help prevent XSS attacks, including automatic nonce generation for scripts.
Modern Email API: The internal email system now uses Python’s modern EmailMessage library, fixing bugs and improving MIME support.

A first look at Django’s new background tasks

Django 6.0 introduces django.tasks, a standard API for background tasks, though it intentionally lacks a built-in worker mechanism for execution. While not immediately replacing robust tools like Celery, it unifies task definitions.

The article demonstrates creating a custom database-backed task queue and worker to send notifications via ntfy.sh. It details defining tasks using the @task decorator, enqueuing them, and retrieving results. Although the native framework currently lacks automatic retries and complex orchestration, the specific implementation shown adds these features, suggesting django.tasks successfully standardizes the majority of common background processing use cases.

Python Workers redux: fast cold starts, packages, and a uv-first workflow

Cloudflare has significantly enhanced Python Workers with three major improvements. First, they’ve achieved dramatically faster cold starts using memory snapshots, reducing average start times to 1.027 seconds - 2.4x faster than AWS Lambda without SnapStart and 3x faster than Google Cloud Run. Second, they’ve integrated comprehensive package support using the uv package manager, allowing developers to use any Pyodide-compatible package (both pure Python and those with dynamic libraries). Third, they’ve created a Python-native developer experience with tools like pywrangler for easy deployment and type hint generation.

The technical innovations include sophisticated memory snapshotting that handles entropy challenges and WebAssembly state preservation. These advancements enable Python developers to deploy applications like FastAPI globally in under 2 minutes, with examples ranging from HTML templating with Jinja to WebSocket-based chat rooms using Durable Objects. The improvements also include sharding to reduce cold start frequency and plans for even faster performance and expanded package support.

Automate Python package releases

This article explains how to fully automate Python package releases using GitHub Actions. The author previously handled releases manually but now uses a workflow that automatically runs tests, lints code, builds the package, publishes to PyPI, and creates GitHub releases with changelogs when a new tag is pushed. The process can be simplified further using tbump to handle version bumps and tagging in one command.

Deprecations via warnings don’t work for Python libraries

Seth Larson discusses how Python’s DeprecationWarning system failed for urllib3, a top-3 Python package. Despite emitting warnings for over 3 years about deprecated APIs, major libraries like Kubernetes client, Fastly client, and Airflow were still broken when the APIs were removed. It concludes that DeprecationWarning doesn’t work for Python libraries because warnings are ignored by default. Possible solutions include creating custom warning categories or adopting SemVer with frequent major version releases instead of relying on warnings for API deprecations.

30 things I’ve learned from 30 years as a Python freelancer

After 30 years as a Python freelancer, Reuven Lerner shares 30 lessons: freelancing requires business skills beyond coding, kindness matters more than brilliance, specialization beats generalization, and personal relationships drive success. He emphasizes continuous learning, work-life balance, fair pricing for global access, and the importance of family time. Despite earning less than corporate peers, he values autonomy, minimal meetings, and helping others learn.

Python Typing Survey 2025: Code Quality and Flexibility As Top Reasons for Typing Adoption

The 2025 Typed Python Survey, conducted by JetBrains, Meta, and the Python typing community, gathered 1,241 responses (15% increase from 2024). Key findings:

Adoption: 86% of respondents “always” or “often” use type hints, with highest adoption (93%) among developers with 5-10 years of Python experience. Most respondents have substantial Python and typing expertise.
Top Benefits: Code quality and flexibility are primary reasons for adoption. Developers value optional gradual adoption, improved readability, enhanced IDE tooling, bug prevention, and system expressiveness.
Major Challenges: Third-party library support issues, complexity of advanced features (generics, TypeVar), tooling ecosystem fragmentation, lack of runtime enforcement, verbosity, and integration with legacy code.
Tooling: Mypy remains dominant (58%), but Rust-based checkers like Pyrefly, ty, and Zuban are gaining traction (20% collectively). VS Code leads as the most popular IDE.
Learning Resources: Official documentation is the top resource, followed by blog posts. LLMs are increasingly used for help (400+ users). Reddit has become a key channel for discovering new developments.
Future Needs: Better library type coverage, improved documentation, tooling consistency, TypeScript-inspired features, runtime type enforcement, and enhanced generics support.

Writing a good `CLAUDE.md`

The CLAUDE.md file helps onboard AI coding agents (like Claude Code) to a codebase by providing essential context—what the project does, why it exists, and how to work on it (e.g., tools, tests). However, LLMs ignore irrelevant instructions, so the file should be short (<300 lines), universally applicable, and avoid overloading with commands or style rules. Use progressive disclosure (separate docs for specific tasks) and rely on linters for formatting. Focus on high-level guidance to maximize relevance and performance.

How uv got so fast

The article explains that uv’s speed advantage over pip stems primarily from design decisions rather than just being written in Rust.

Key factors:

Modern standards (PEP 518, 517, 621, 658) enabled static metadata, eliminating the need to execute code to discover dependencies — a “chicken-and-egg” problem that forced pip to run untrusted setup scripts.
Dropped legacy features: uv eliminates support for .egg files, pip.conf, bytecode compilation, and system Python installation. It enforces stricter specs, ignores overly defensive Python version upper bounds, and uses “first-index-wins” for multiple indexes.
Language-agnostic optimizations: Parallel downloads, global caching with hardlinks, HTTP range requests for metadata, Python-free resolution by parsing TOML directly, and the PubGrub resolver algorithm (which applies conflict-driven clause learning from SAT solvers).
Rust-specific benefits: Zero-copy deserialization, thread-level parallelism (avoiding Python’s GIL), no interpreter startup costs, and compact version representation.

Conclusion: uv is fast mainly because it starts fresh with modern assumptions and drops 15 years of legacy compatibility constraints, not because of Rust alone.

Effective harnesses for long-running agents

Anthropic researchers developed a two-part solution to enable AI agents to work effectively across multiple context windows. The approach uses an “initializer agent” to set up the environment on the first run and a “coding agent” that makes incremental progress in each session while leaving clear artifacts for the next. Key components include feature lists, git commits, progress tracking files, and structured testing. This addresses problems where agents try to do too much at once, declare victory prematurely, or leave environments in buggy states between sessions.

Why I Ignore The Spotlight as a Staff Engineer

Lalit Maganti, a Senior Staff Engineer at Google, advocates for a career specifically focused on “stewardship” rather than chasing the “spotlight.” Contrasting his infrastructure role with product engineers who must pivot frequently for executive visibility, Maganti argues for long-term ownership of stable systems.

By building internal developer tools like Perfetto, he operates “bottom-up,” solving deep technical problems for other engineers rather than chasing quarterly business metrics. Maganti asserts that treating engineers as fungible assets destroys context. Conversely, staying with a system unlocks “compounding returns,” enabling systemic innovations—such as his creation of Bigtrace—that require deep historical knowledge to identify.

This long-term reliability grants the political capital to resist hype cycles, such as unnecessary AI integration, thus protecting product integrity. He proposes an alternative path to promotion based on a “Shadow Hierarchy,” where success is measured by how much critical internal teams rely on your tools, rather than executive acclaim. Ultimately, valid high-impact careers in Big Tech can represent a choice for depth, patience, and building lasting foundations over rapid, flashy launches.

2025 LLM Year in Review

In his “2025 LLM Year in Review”, Andrej Karpathy highlights six paradigm shifts that redefined AI:

RLVR (Reinforcement Learning from Verifiable Rewards): Moving beyond RLHF, models now train against objective rewards (e.g., math/code), fostering spontaneous reasoning strategies and “thinking time” scaling laws, pioneered by OpenAI’s o1/o3.
Ghosts vs. Animals: Karpathy describes LLM intelligence as “summoning ghosts”—jagged, non-human entities that excel in verifiable domains but remain vulnerable to simple failures. This has led to a loss of trust in traditional, easily “gamed” benchmarks.
The LLM App Layer: Cursor exemplifies a new “thick” application layer that orchestrates complex LLM workflows, context engineering, and custom GUIs for specific verticals.
Local Agents: Claude Code demonstrated the power of agents living directly on a user’s computer, prioritizing local context and low-latency interaction over cloud-only deployments.
Vibe Coding: AI has enabled “vibe coding,” where natural language allows anyone to create software. This makes code disposable, ephemeral, and accessible to non-professionals.
LLM GUIs: Models like “Gemini Nano Banana” suggest a shift from text-heavy chat to visual/spatial interfaces (infographics, apps), aligning AI output with human visual preferences.

Karpathy concludes that while LLMs are both smarter and dumber than expected, the field remains wide open with vast untapped potential.

Software Engineering in 2026

Progress in AI-powered coding tools, especially using large language models (LLMs), has significantly reduced the time and cost of producing quality code. However, the real bottlenecks in software engineering are shifting from coding to system design, evolution, and operations, which are less affected by AI.

Key trends for 2026:

Infrastructure must be abstracted and self-service, easy for both humans and LLMs, minimizing the need for dedicated infrastructure engineers.
Continuous Integration (CI) tooling grows in importance as AI agents generate more code, pushing for deeper automated testing and verification.
Human-guided abstractions and “system taste” remain crucial; without them, LLM-generated code risks increasing technical debt.
Human code reviews are a new bottleneck, focusing mainly on sensitive or performance-critical changes. Junior engineers need to develop review intuition earlier.
Project timeline estimates will vary more, as some tasks are aided by LLMs while complex, context-heavy work is less suitable for automation.
The cost reduction in coding may tip some SaaS “build vs buy” decisions towards building for larger tech firms, but infrastructure/compliance needs will likely remain outsourced.

Podcasts

🥝 core.py

Calling Things, Part 1

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

Repositories

agentskills

This repo contains the specification, documentation, and reference SDK for Agent Skills, which recently goes open.

mistralai/mistral-vibe (Apache-2.0)

Mistral Vibe CLI is an open-source command-line coding assistant powered by Devstral, Mistral’s “next-generation coding model”. It explores, modifies, and executes changes across your codebase using natural language—in your terminal or integrated into your preferred IDE via the Agent Communication Protocol.

raine/workmux (MIT)

workmux is a command-line tool designed to streamline parallel development workflows by integrating Git worktrees directly with tmux windows.

Zero-Friction Parallel Dev: It allows you to spin up isolated development environments instantly. One command creates a new git worktree (a separate checkout of your project) and a dedicated tmux window for it.
Automated Setup: Through a configuration file (.workmux.yaml), you can define exactly how that tmux window should look (e.g., split panes with an editor open in one and a shell in the other) and what commands to run immediately (like installing dependencies).
Environment Management: It handles the tedious parts of creating new environments, such as copying or symlinking .env files or node_modules to the new worktree so you don’t have to set them up manually.
Cleanup: When you are finished with a task, a single merge command merges your branch, deletes the worktree, and closes the tmux window, keeping your workspace clean.
AI Agent Focus: The documentation highlights that this workflow is particularly perfect for running multiple AI agents in parallel without them conflicting with each other.

Have time for some fun?

The Game Awards 2025

The Game Awards (TGA) 2025 was held on December 11th, 2025 at Peacock Theater in Los Angeles, California. Clair Obscur: Expedition 33, with a record-breaking 12 nominations, took home the award for Game of the Year (GOTY) along with 8 other awards. Check out the official website for everything you want to know.

Alright, that concludes the December and this year’s last edition of “This Month for Pythonistas”. Thank you again for reading my posts for this whole year! I hope you enjoy them or find something useful. Happy coding, Merry Christmas 🎄, and see you in 2026! 👋

This Month for Pythonistas - November 2025

Zeyang Lin — Sun, 30 Nov 2025 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2025 11

Welcome back Pythonistas! I’m glad to see you back reading the ninth issue of my “This month for Pythonistas” series which curates the news, articles, tutorials, podcasts, and more Python stuff worth noting in this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

PyCon US 2026 CFP is Open

The 2026 PyCon US call for proposals (CFP) for Talks, Charlas, Tutorials and Posters is open until December 19th, 2025. Don’t miss out on the largest Python conference in the world!

PyCon Ireland 2025

PyCon Ireland this year took place November 15-16 in UCD O’Reilly Hall, Dublin, featuring two talk tracks and two workshop tracks on both days.

20th anniversary of first ever Django release

For the past twenty years, Django has shipped over 440 releases, making it among the most popular and successful Python web frameworks. You can read more about it here.

New Versions

Python 3.15.0 alpha 2

This is the second developer preview of the upcoming Python 3.15 release. It is available for download here.

Django 6.0 RC 1

Django 6.0 release candidate 1 is now available. The provisional release notes can be found here.

Provided no major bugs are discovered that can’t be solved in the next two weeks, Django 6.0 will be released on or around December 3.

pytest 9.0

pytest 9.0 brings significant improvements including native TOML configuration support, a new strict mode for better testing practices, and the long-awaited subtests feature.

Tutorials

DeepLearning.ai’s Jupyter AI: AI Coding in Notebooks by Andrew Ng and Brian Granger

In this course, you’ll build a book research assistant using the Open Library API, and create a stock market data analysis workflow, all with the help of Jupyter AI. You’ll learn how to provide API documentation as context so the LLM generates accurate syntax for code that wasn’t part of its pretraining.

DeepLearning.ai’s Semantic Caching for AI Agents from Redis

In this course, you’ll build a semantic cache that makes your AI agents faster and more cost-effective by recognizing when different questions mean the same thing. For example, when someone asks “How do I get a refund?” and another asks “I want my money back”， your cache will reuse the answer instead of making another API call, reducing the need for redundant model calls.

DeepLearning.ai’s Design, Develop, and Deploy Multi-Agent Systems with CrewAI

Disclaimer: This course contains a small portion of content which requires a paid PRO subscription to access.

Learn how to build multi-agent systems that automate complex, end-to-end workflows. You’ll create intelligent agent teams that plan, reason, and collaborate using tools, memory, and guardrails, and learn how to scale them for production.

RealPython’s Python MarkItDown: Convert Documents Into LLM-Ready Markdown

The MarkItDown library lets you quickly turn PDFs, Office files, images, HTML, audio, and URLs into LLM-ready Markdown. In this tutorial, you’ll compare MarkItDown with Pandoc, run it from the command line, use it in Python code, and integrate conversions into AI-powered workflows.

Build a coding agent with GPT 5.1

In this guide, we’ll use the Agents SDK to build a coding agent that can scaffold a brand-new app from a prompt and refine it through user feedback.

Articles

Why Performance Matters in Python Development

Disclaimer: This article contains promotional content regarding JetBrains products.

The blog from JetBrains emphasizes Python performance optimization as a strategic business imperative, not just technical concern. Despite Python’s interpreted nature and GIL limitations, most bottlenecks stem from code-level inefficiencies. Performance impacts user experience, scalability, infrastructure costs, and development velocity. Key optimization areas include algorithmic improvements, proper data structures, I/O batching, and appropriate parallelism (threading for I/O-bound, multiprocessing for CPU-bound tasks). The article dispels myths about Python being universally slow, emphasizing profiling-driven optimization over intuition.

await is Not a Context Switch: Understanding Python’s Coroutines vs Tasks

This blog post clarifies a critical distinction in Python’s asyncio: unlike JavaScript or C#, awaiting a coroutine does not automatically yield control to the event loop. In Python, await synchronously executes a coroutine until a suspension occurs; true concurrency and interleaving mainly happen with explicitly created Tasks (asyncio.create_task). This means critical sections without internal await statements are atomic relative to the event loop. Understanding this prevents unnecessary locking, as race conditions only occur at specific suspension points, not at every async function call.

__slots__ for optimizing classes

Python classes store instance attributes in a __dict__ dictionary by default, allowing dynamic addition but consuming memory. Defining __slots__ = ('attr1', 'attr2', ...) replaces __dict__ with a fixed, efficient array-like structure. Benefits: restricts attributes (no extras allowed), reduces memory usage (e.g., from 271KB to 176KB for 1M Point objects), and speeds up attribute lookups. Ideal for classes with many instances or frequent access.

Choose the Right Text Pattern Tool: Regex, Pregex, or Pyparsing

This article compares three Python text pattern matching tools: regex (regular expressions), pregex (human-readable regex alternative), and pyparsing (grammar-based parsing). It teaches when to use each tool for extracting emails, phone numbers, and parsing structured data. The guide helps developers choose the right approach for different text processing scenarios in Python.

How to use UUIDv7 in Python, Django and PostgreSQL

This guide explains using UUIDv7 – time-ordered IDs for better index locality than UUIDv4 – in Python 3.14 (uuid.uuid7()), Django 5.2 models, and PostgreSQL 18 (native uuidv7() generation and uuid_extract_timestamp() via GeneratedFields). Covers setup, migrations, client-side (SQLite) vs. DB-side generation, testing, and considerations for other databases like MySQL/Oracle. Recommends masking (UUIDv47) for public APIs to hide timestamps.

Python package managers: uv vs pixi?

This post compares Python package managers uv (fast Rust pip reimplementation for PyPI) and pixi (next-gen conda for PyPI + conda-forge). uv suits scripts, apps, libraries; pixi excels in AI/CUDA/science with compiled deps. Historical evolution: pip → conda binaries → mamba speed → declarative locking. Author’s recommendations: uv for most, pixi for GPU/research, conda+uv for interdependent libs.

Introducing GPT-5.1 for developers

OpenAI has released GPT-5.1 for the API platform, a model designed to balance intelligence and speed for agentic and coding tasks. It features adaptive reasoning, where the model dynamically adjusts thinking time based on task complexity—processing simple requests significantly faster while remaining persistent on difficult problems.

Key updates include:

No Reasoning Mode: A setting for ultra-low latency tasks like tool calling and search, behaving like a standard non-reasoning model but with GPT-5.1’s intelligence base.
Extended Prompt Caching: Supports up to 24-hour cache retention to lower costs and latency for long-context workflows.
New Developer Tools: Introduces apply_patch for reliable, structure-aware code editing and a shell tool for executing local commands.
GPT-5.1 utilizes a more steerable coding personality and outperforms GPT-5 on benchmarks like SWE-bench Verified (76.3%). It is available immediately to developers on paid tiers, with pricing matching GPT-5. Specialized codex versions were also released for agentic coding workflows.
A new era of intelligence with Gemini 3

Google has introduced Gemini 3, its most intelligent and capable AI model to date. Gemini 3 Pro delivers state-of-the-art performance in multimodal reasoning, coding, and long-horizon planning, outperforming previous models on major benchmarks like Humanity’s Last Exam.

Key features include:

Enhanced Reasoning: The model offers deeper nuance and reduced sycophancy. A new Deep Think mode, coming soon to Ultra subscribers, pushes reasoning capabilities even further for complex problem-solving.
Developer Tools: Google launched Antigravity, a new agentic development platform where AI agents can autonomously plan, code, and validate software.
Practical Applications: Gemini 3 helps users learn by synthesizing diverse inputs (like video and text), build complex apps via “vibe coding,” and handle multi-step planning tasks for daily life.
Gemini 3 is available immediately across Google products, including the Gemini app, AI Studio, Vertex AI, and within Google Search’s AI Mode. The release emphasizes robust safety testing and improved resistance to misuse.
ADK architecture: When to use sub-agents versus agents as tools

This blog post compares sub-agents vs. agents as tools in multi-agent AI systems. Agents as tools are stateless, reusable for discrete tasks (e.g., NL2SQL, DB execution) with isolated context. Sub-agents are stateful, collaborative for complex workflows (e.g., data visualization, travel planning) sharing parent context. Decision matrix: Use tools for low-complexity/reusable tasks; sub-agents for high-complexity/stateful processes. Real-world cases include data analysis and trip planning.

The Learning Loop and LLMs

The article argues that software development is fundamentally a learning process, not an assembly line. While LLMs excel at removing friction and generating code, they cannot replace the essential learning loop of observe-experiment-apply. True expertise comes from hands-on experience and understanding, not just AI-generated solutions. LLMs are best used as brainstorming partners, not autonomous builders, to avoid the “maintenance cliff” where systems become unmaintainable due to lack of deep understanding.

why agents DO NOT write most of our code - a reality check

The article provides a reality check on AI coding agents. Despite building AI agents themselves, Octomind finds that most of their code is still written by humans. Through practical experiments, the author reveals that AI agents struggle with maintaining codebase mental models, produce overly verbose code (1000+ line PRs), lack self-reflection about their limitations, and often miss critical issues like transaction handling. While AI is valuable for brainstorming, debugging, and small tasks, the dream of agents writing most production code remains far from reality.

Becoming a Core Developer

Stefanie Molin became a numpydoc core developer by creating a pre-commit hook for docstring validation. Starting from fixing docstrings at a Scikit-Learn sprint, she developed AstValidator using Python’s ast module for static analysis, avoiding code execution. This led to numpydoc-validation (v1.6.0+), with CLI linting and config via pyproject.toml. After PR merge and improvements, she joined as core dev in April 2024.

What caused the large AWS outage?

A major AWS outage on October 20, 2025 was caused by a DynamoDB DNS failure in us-east-1. The 14-hour incident started when race conditions between DNS enactors emptied DynamoDB’s DNS records, making the database appear offline. This cascaded to EC2’s droplet management system, causing capacity shortages and network connectivity issues that took 12+ hours to fully resolve.

Cloudflare outage on November 18, 2025

On November 18, 2025, Cloudflare experienced a significant outage starting at 11:20 UTC that disrupted traffic across its network, causing widespread HTTP 5xx errors for customer websites and impacting services like Workers KV, Access, and the Dashboard.

The outage was not caused by a cyberattack but by an internal configuration error. A change to database permissions caused a query to generate duplicate entries in a “feature file” used by Cloudflare’s Bot Management system. This doubling in file size exceeded a hardcoded memory limit within the core proxy software, causing the system to crash (panic) globally.

Cloudflare engineers initially suspected a DDoS attack but soon identified the corrupt file. They resolved the issue by halting the bad file’s propagation and manually reverting to a known good version. Core traffic began flowing normally by 14:30 UTC, and all systems were fully restored by 17:06 UTC. Cloudflare has apologized and is implementing new safeguards, such as stricter file validation and global kill switches, to prevent future occurrences.

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

Repositories

hyperflask (MIT)

hyperflask is a Flask-based (very) opiniated full-stack web framework where all the tech choices have been made. It combines multiple Flask extensions and frontend libraries into a seamless experience.

langchain-ai/deepagents (MIT)

Primarily inspired by Claude Code, deepagents is an agent harness built on langchain and langgraph, which is equipped with a planning tool, a filesystem backend, and the ability to spawn subagents - making them well-equipped to handle complex agentic tasks.

MoonshotAI/kimi-cli (Apache 2.0)

Kimi CLI is yet another command-line agent but built within Python ecosystem unlike other Claude Code-alike tools. Apart from agentic coding, it can also be switched to “shell mode” where you can run (some of) shell commands.

MemMachine (Apache 2.0)

MemMachine is a open-source, “universal” memory layer for AI agents which persists across multiple sessions, agents, and large language models. It provides Python SDK, RESTful API as well as MCP for easy integration with agents.

OpenRouterTeam/python-sdk (Apache 2.0)

This is OpenRouter’s official Python SDK, a type-safe toolkit for building AI applications with access to 300+ language models through a unified API. You can find the docs here.

Have time for some fun?

Golden Joystick Awards 2025

The Golden Joystick Awards revealed its winners for 2025 on November 20th! Congratulations to the winners, especially Clair Obscure Expedition 33 which was crowned the Ultimate Game of the Year (UGOTY) along with other six thophies, for their outstanding contributions to the video game industry!

Alright, that concludes the November Edition of “This Month of Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in December!

[one-liner] Install Kiro Cli

Zeyang Lin — Tue, 18 Nov 2025 08:20:00 GMT

One-Liner series: Kiro Cli

source: kiro.dev docs

Install on Linux/macOS

curl -fsSL https://cli.kiro.dev/install | bash

Important note on Amazon Q CLI

If Amazon Q CLI was already installed, running the script above would result in:

Kiro CLI installer:

Detected existing Amazon Q CLI installation
Kiro CLI is the new version of Amazon Q CLI. Updating to latest version.


⚠️ Q CLI at /usr/bin/q does not support auto-update. Please uninstall it and rerun this script to install Kiro CLI.

To uninstall Q CLI, run:

sudo apt remove amazon-q

If succeeded, run the kiro-cli script again:

curl -fsSL https://cli.kiro.dev/install | bash

It should install Kiro CLI:

Kiro CLI installer:

Downloading package...
✓ Downloaded and extracted
✓ Package installed successfully

🎉 Installation complete! Happy coding!

Next steps:
Use the command "kiro-cli" to get started!

This script would install Kiro Cli into current user’s .local/ directory:

which kiro-cli

/home/******/.local/bin/kiro-cli

Update

kiro-cli update

[one-liner] Install Claude Code (Native Build)

Zeyang Lin — Sun, 02 Nov 2025 08:09:00 GMT

One-Liner series: Claude Code (Native Build)

source: Claude Docs

Install on Linux/macOS/WSL

curl -fsSL https://claude.ai/install.sh | bash

Install on Windows (PowerShell)

irm https://claude.ai/install.ps1 | iex

Update

claude update

This Month for Pythonistas - October 2025

Zeyang Lin — Fri, 31 Oct 2025 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2025 10

Welcome back Pythonistas! In this big month for Python community, I’m glad to see you back reading the eighth issue of my “This month for Pythonistas” series which curates the news, articles, tutorials, podcasts, and more Python stuff worth noting in this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

OpenAI DevDay 2025

OpenAI DevDay 2025 was held on October 6, 2025 at Fort Mason in San Francisco. The keynote was delivered by CEO Sam Altman and featured special guest Jony Ive, the renowned Apple designer. The event focused on empowering developers to build groundbreaking applications faster than ever.

Highlights include:

Apps in ChatGPT and Apps SDK
AgentKit
Sora 2 and Sora 2 Pro
GPT-5 Pro API
Codex General-Available
GPT-Realtime-mini

Github Universe 25

At Github Universe 25, which was held on October 28 - 29, 2025, GitHub announces Agent HQ - a unified platform bringing coding agents from Anthropic, OpenAI, Google, Cognition, and xAI directly into GitHub workflows as part of Copilot subscriptions. Features include mission control for managing agents across devices, VS Code integration with plan mode and custom agents, enterprise governance tools, code quality checks, and metrics dashboards. It would be available starting with OpenAI Codex for Copilot Pro+ users in VS Code Insiders.

A comprehensive recap can be found here.

New Versions

Python 3.14.0 final

Python 3.14 (Pi, 𝜋, or Pie) is finally here! This release brings officially supported free-threaded build and lots of new features. Besides, Python 3.13.9 is also released.

Python 3.12.12, 3.11.14, 3.10.19 and 3.9.24 are the latest security-only releases.

Python 3.9 is reaching End-Of-Life this October, so don’t forget to upgrade!

Python 3.15.0 alpha 1

Python 3.15.0 alpha 1 is the first of seven planned alpha releases for the Python 3.15 series. Key highlights include:

Statistical Sampling Profiler (PEP 799): A new high-performance profiling tool with virtually zero overhead that can sample at up to 1,000,000 Hz
UTF-8 as Default Encoding (PEP 686): Python now uses UTF-8 as the default encoding for I/O operations, improving cross-platform compatibility
New C API (PEP 782): Introduction of PyBytesWriter for creating Python bytes objects
Improved Error Messages: Enhanced developer experience with better error reporting

LangChain 1.0 & LangGraph 1.0

This version marks LangChain’s commitment to stability with no breaking changes until 2.0, while reducing complexity and focusing on core agent functionality.

CrewAI 1.0

CrewAI 1.0 represents the transition from beta/experimental to production-grade enterprise solution, with better stability, enterprise features, and a more mature ecosystem while maintaining the core multi-agent orchestration capabilities.

PyTorch 2.9

The 2.9 release focuses on enhancing multi-GPU programming, expanding hardware compatibility, and improving the developer experience for C++ extensions while maintaining performance optimizations.

Major New Features include:

Symmetric Memory: New feature enabling easier multi-GPU kernel programming
Enhanced torch.compile: Ability to arbitrarily toggle error or resume on graph breaks
Expanded Hardware Support: Added ROCm, XPU, and CUDA 13 wheel variants
FlexAttention: Now enabled on Intel GPUs with flash decoding optimization on x86 CPUs
Arm Platform: Improvements and optimizations for Arm architecture
Linux aarch64: Binary wheel builds across all CUDA versions

isort 7.0

isort 7 is a conservative major release focused on updating Python version support and maintaining compatibility with newer Python versions. The changes are relatively minor compared to the major architectural changes seen between versions 4.x → 5.x. The main impact for users will be the requirement for Python 3.10+ and improved debugging information for file processing.

Ubuntu 25.10

Ubuntu 25.10 “Questing Quokka” is released! It “introduces GNOME 49 with media and power controls on the lock screen, HDR brightness settings, and enhanced accessibility features in line with the European Accessibility Act.”

It “also debuts Rust-based implementations of sudo and coreutils for improved memory safety, and adopts the new RVA23 profile as the baseline for RISC-V, paving the way to Ubuntu 26.04 LTS.”

Other spins like Xubuntu, Lubuntu, Kubuntu, edubuntu, and Ubuntu Studio are also released. Pick your favorite and start coding!

Tutorials

DeepLearning.ai’s Agentic AI by Andrew Ng

In this course taught by Andrew Ng, you’ll gain a fundamental understanding and practical knowledge to develop production-ready agentic applications, from design patterns to deployment and evaluation.

DeepLearning.ai’s Building Live Voice Agents with Google’s ADK from Google

You’ll learn how to build and deploy AI agents with Google’s open source Agent Development Kit (ADK). ADK provides modular components such as models, tools, memory, and orchestration, that make it easier to create both simple and complex systems.

DeepLearning.ai’s Governing AI Agents from databricks

Explore what it means to govern an agent, how to apply governance policies to a real dataset in Databricks, and how to add observability to track and debug performance. Through this course, you’ll know how to build agents that handle data responsibly while maintaining visibility, and safety.

Articles

Python 3.14: Cool New Features for You to Try

As usual, RealPython has a great article on the very latest Python version. This time it compiles a list of the new features in Python 3.14 (eg. t-strings, colorful REPL, deferred annotation evaluation) and demonstrates how to play with them.

Python 3.14 Is Here. How Fast Is It?

Python 3.14 is the fastest CPython release yet, showing significant improvements over previous versions. Benchmarks tested Fibonacci calculations and bubble sort algorithms across single-threaded and multi-threaded scenarios. Key findings show 3.14 running 27% faster than 3.13 for recursive functions. While the new JIT interpreter showed minimal gains, the free-threading variant delivered impressive 3x speed improvements for CPU-heavy multi-threaded workloads due to GIL removal. PyPy remained exceptionally fast, outperforming even Node.js in some tests, while Rust demonstrated the highest performance overall.

The future of Python web services looks GIL-free

Python 3.14’s free-threaded implementation (no GIL) shows promising results for web services. Benchmarks reveal ASGI apps maintain similar performance with 20% lower memory usage, while WSGI apps see 3-4x throughput improvements for CPU-bound tasks. Despite 5-10% performance penalty in pure Python Python code, the elimination of GIL contention enables true multi-core utilization, potentially revolutionizing Python web deployment by simplifying concurrency and reducing memory requirements.

T-strings: Python’s Fifth String Formatting Technique?

Python 3.14 introduces t-strings, a fifth string formatting technique that returns Template objects instead of strings. Unlike f-strings which immediately interpolate values, t-strings enable lazy string interpolation - useful for library authors who need to pre-process inputs (like escaping SQL/HTML) before final string creation. T-strings use t"..." syntax and are primarily designed for tool/library maintainers, not typical Python developers.

Build Production-Ready LLM Agents with LangChain 1.0 Middleware

This tutorial demonstrates how to build production-ready LLM agents using LangChain 1.0’s new middleware architecture. It covers five essential middleware components:

Message Summarization: Manages context windows by condensing conversations
PII Filtering: Protects sensitive data through automatic redaction
Human-in-the-Loop: Adds approval workflows for sensitive actions
Task Planning: Structures complex requests into manageable subtasks
Intelligent Tool Selection: Pre-filters tools to reduce costs and improve accuracy

The middleware follows web server patterns, providing reusable, testable components that can be composed together. Each focuses on a single responsibility (monitor, modify, control, or enforce) and integrates seamlessly to build robust production agents with minimal infrastructure code.

Django: one ORM to rule all databases 💍

This article provides a comprehensive comparison of Django ORM features across PostgreSQL, SQLite, MariaDB, MySQL, and Oracle. It includes detailed feature matrices showing support levels (✅/⚠️/🚫) for various functionality including field types, constraints, query features, transactions, and GIS capabilities, using fictional data to illustrate what an automated feature comparison matrix could look like in Django’s official documentation.

Why Reactive Programming Hasn’t Taken Off in Python (And How Signals Can Change That)

Reactive programming hasn’t gained traction in Python because existing tools like RxPY are designed for event streams and require complex subscription management. However, signal-based reactive programming offers Python developers automatic state synchronization like spreadsheet formulas, reducing bugs and improving maintainability. The reaktiv library provides transparent, synchronous updates where derived values automatically stay in sync with base data without manual coordination.

From Claude Code to Agentic RAG

The article advocates moving from traditional vector-based RAG systems to “agentic retrieval” - letting LLMs reason through documents directly. It introduces PageIndex, a vectorless hierarchical indexing system that creates human-like table-of-contents trees. Instead of complex vector databases, it gives LLMs navigational tools to find and retrieve relevant content, mirroring how Claude Code uses simple tools like grep. PageIndex achieved 98.7% accuracy on FinanceBench while requiring minimal infrastructure.

Vibe engineering

Simon Willison proposes “vibe engineering” as the opposite of “vibe coding” - a sophisticated, accountable approach where experienced engineers use AI tools like coding agents responsibly. This method rewards advanced software practices: comprehensive testing, planning, documentation, version control, and good management skills.

State of LLMs in Late 2025

The 2025 LLM landscape is hyper-specialized, moving from single generalist models to a diverse ecosystem where each model has distinct strengths. The article analyzes GPT-5’s unified intelligence system with automatic model switching, Claude Sonnet 4.5’s coding dominance (77% SWE-bench), open-source Llama 4 variants with 10M token contexts, Grok 4’s mathematical supremacy, and efficient alternatives like Mistral. It provides practical guidance on choosing the right model based on specific use cases rather than “which is smartest,” reflecting the era of tailored AI tools for specific tasks.

Two things LLM coding agents are still bad at

LLM coding agents struggle with two key areas. First, they don’t use copy-paste operations—instead of moving code directly, they delete from the source and write from memory into the destination, which feels unnatural compared to human programming habits. Second, they’re terrible at asking clarifying questions when uncertain; instead they make assumptions and brute-force solutions until hitting walls.

AI can code, but it can’t build software

The article argues that while AI can generate code, it cannot truly “build software” - the complex engineering required to create production-ready applications. Coding is solving isolated problems, but software engineering involves managing complexity, integration, and long-term maintainability. AI can demo features, but transforming prototypes into robust systems requires human expertise, explaining why non-technical founders still seek technical co-founders despite AI tools.

Podcasts

🥝 core.py

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

#203: Automating API Documentation with Zylosystems

🚀 VS Code Insiders Podcast

Repositories

claude-agent-sdk-python (MIT)

Claude Code SDK is renamed to Claude Agent SDK. It helps developers build powerful autonomous agents using Claude.

microsoft/agent-framework (MIT)

MAF is Microsoft’s comprehensive multi-language framework for building, orchestrating, and deploying AI agents with support for both .NET and Python implementations. It’s developed by the core AutoGen and Semantic Kernel teams at Microsoft, and is designed to be a new foundation for building AI applications going forward.

microsoft/agent-lightning (MIT)

“The absolute trainer to light up AI agents.”

PageIndex (MIT)

PageIndex is a Vector-less, reasoning-based RAG system that simulates how human experts navigate and extract knowledge from long documents through tree search, enabling LLMs to think and reason their way to the most relevant document sections.

/dev/push (MIT)

/dev/push is a open-source Platform as a Service (PaaS) written in Python and HTML for developers to build and deploy their applications. It is self-hostable and can be considered as an alternative to Vercel, Netlify, etc.

mitmproxy/pdoc (MIT-0)

pdoc is a Python library for generating API documentation from code and comments.

ludo-technologies/pyscn (MIT)

pyscn is a Python code quality analyzer written in Go. It detects dead code, tracks module dependencies, and analyzes complexity, etc. to make your code base more maintainable.

Alright, that concludes the October Edition of “This Month of Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in November!

This Month for Pythonistas - September 2025

Zeyang Lin — Tue, 30 Sep 2025 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2025 9

Welcome back Pythonistas! I’m glad to see you back reading the seventh issue of my “This month for Pythonistas” series which curates the news, articles, tutorials, podcasts, and more Python stuff worth noting in this month.

Before we continue, please note that this blog is synced across several platforms:

Ready? Let’s get started!

DjangoCon US 2025 was held in Chicago, United States.
PyCon UK 2025 was held in Manchester, England.
PyCon China 2025 was held in Shanghai, China.

New Versions

Python 3.14 RC3

This is the final release preview before 3.14 final, which is scheduled for Tuesday, 2025-10-07.

Source tarball and binary releases are available here.

Tutorials

Deeplearning.ai’s Knowledge Graphs for AI Agent API Discovery from SAP

You’ll implement API discovery that starts with semantic retrieval to reduce the API selection space, then adds APIs connected by business-process edges. The result is a small, relevant subset of APIs that includes the information about the process sequence the agent should follow.

Deeplearning.ai’s Build AI Apps with MCP Servers: Working with Box Files from Box

Build an LLM-powered invoice app that processes local PDF invoices to extract fields such as client name, total amount, and purchased product, and generates per-client reports.

DeepLearning.ai’s Building and Evaluating Data Agents from snowflake

You’ll know how to build, trace, and evaluate a multi-agent workflow that plans tasks, pulls context from structured and unstructured data, performs web search, and summarizes or visualizes the final results.

Guide to Agentic AI – Build a Python Coding Agent with Gemini

This project-based tutorial provides a deep understanding of how powerful AI tools work by guiding you through the creation of an agentic loop powered by tool calling. You will implement the core abilities for your agent to interact with and modify a codebase, including reading files, writing to files, and executing code to get feedback.

Articles

Python has had async for 10 years – why isn’t it more popular?

Python’s async / await (introduced 2015) remains niche due to limited I/O use cases (excludes disk ops, reliant on GIL), fragmented ecosystem (Flask/Django’s patchy async adoption, duplicated sync/async APIs), and testing complexity. FastAPI’s rise indicates async success in web contexts, but 3.14’s free-threading/sub-interpreter features may reduce async reliance.

Python: fix SyntaxWarning: 'return' in a 'finally' block

Python 3.14+ warns about return/break/continue in finally blocks (PEP 765) as they override preceding flow control. Always returns the finally block’s value, causing silent bugs. Fix it by restructuring code to avoid these keywords in finally blocks—move returns to except blocks or remove unnecessary exception handling.

Building your own CLI Coding Agent with Pydantic-AI

This article details building a custom CLI coding agent using Pydantic-AI and Model Context Protocol. Unlike commercial tools, a custom agent can be tailored to specific project needs, understanding project context and conventions. The agent combines Claude with specialized MCP servers for testing, code execution, documentation access, internet search, and file operations. Through incremental capabilities—from simple test running to full codebase management—the agent evolves into an intelligent development partner that maintains context, provides structured reasoning, and can autonomously debug and implement solutions.

Static Sites with Python, uv, Caddy, and Docker

This blog post explains the author’s deployment stack for Python-built static sites using uv, Caddy, and Docker. The author details a multi-stage Docker build approach: first stage uses uv with Python 3.13 to build the site, second stage uses Caddy’s Alpine image to serve static files. The setup includes custom Caddy configurations for reverse proxying analytics and handling custom error pages, domains, and content types.

Where to Host a Python Web App

The article compares hosting options for Python web apps, recommending Heroku for non-Docker apps due to its excellent developer experience. Render offers a cheaper Heroku alternative, while Fly.io is usually the cheapest but requires more configuration. AWS ECS suits AWS-experienced users, and self-hosting is only viable with dedicated ops teams. Docker usage significantly impacts hosting choice. The author strongly recommends autoscaling regardless of platform choice, with Heroku being their top pick when prioritizing developer experience and reliability.

AI-Assisted Development: A Three-Act Play

The article presents three distinct approaches to AI-assisted software development: “Vibe Coding” (AI builds apps through chat iterations), “Copilot” (AI assists with planned code sections requiring human review), and “HUD” (AI serves as an intelligent code-completion tool). Author explains these methods aren’t mutually exclusive but suited for different tasks—designers prefer vibe-coding for rapid prototypes while developers use HUD (Cursor’s Tab) for production code.

Parallel AI Agents Are a Game Changer

Parallel AI agents represent a major shift in software development, allowing multiple AI agents (like GitHub Copilot) to work simultaneously on different tasks. Instead of coding one feature at a time, developers can assign 10-20 issues to agents working in parallel, then focus on reviewing and refining their output.Success requires good system documentation, fast CI/CD, monorepo architecture, and skills in problem decomposition and code review rather than line-by-line coding.

Writing effective tools for agents — with agents

The post explains how to create effective tools for AI agents using an evaluation-driven approach. Key insights include: building targeted tools for specific workflows rather than generic APIs, using clear namespacing to avoid confusion, returning meaningful context efficiently, and optimizing for token usage. The authors recommend prototyping quickly, creating comprehensive evaluations with real-world tasks, and collaborating with Claude itself to iteratively improve tool performance. Best practices involve designing tools that mirror human problem-solving while providing rich functionality under the hood.

Building Agents with the Claude Agent SDK

The Claude Code SDK is now Claude Agent SDK. It helps developers build powerful autonomous agents using Claude. The framework operates on a feedback loop: gather context → take action → verify work → repeat. Key features include agentic search, tools/actions, subagents, MCP integrations, code generation, and verification methods.

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

#202: Behind the scenes at Pybites with Bob and Julian

VS Code Insiders Podcast

Repositories

langchain-ai/open-swe (MIT)

OpenSWE is an open-source, cloud-based asynchronous coding agent built with LangGraph. It autonomously understand codebases, plans solutions, and executes code changes across repositories - creating issues and pull requests automatically. Features include human-in-the-loop feedback, parallel execution, and can be launched via web UI or GitHub issues with the “open-swe” label.

google-agentic-commerce/AP2 (Apache 2.0)

Agent Payments Protocol (AP2) is Google’s initiative for secure, interoperable AI-driven payments. This repository provides code samples and demos using ADK and Gemini, with Python/Android scenarios for shopping agents. Features setup instructions, quickstart guides, and authentication via Google API Key or Vertex AI.

deepseek-ai/DeepSeek-V3.2-Exp

As an intermediate step toward DeepSeek’s next-generation architecture, V3.2-Exp builds upon V3.1-Terminus by introducing DeepSeek Sparse Attention—a sparse attention mechanism designed to explore and validate optimizations for training and inference efficiency in long-context scenarios.

Have time for some fun?

Tokyo Game Show 2025 took place from September 25-28, 2025, featuring numerous major game announcements and reveals across various platforms.

Major Xbox Announcements:

Forza Horizon 6: The highly anticipated racing game was officially revealed
Gungrave G.O.R.E Blood Heat: A new entry in the action series
007: First Light: A James Bond title
Aniimo: A rhythm-based game
Double Dragon: Revive: The classic franchise returns
Hotel Barcelona: An adventure game
Rhythm Doctor: A music/rhythm game
Hitman: New content or entry in the franchise

Capcom Presentations:

Pragmata: Updates revealed for this highly anticipated title
Street Fighter 6: Continued support and new content
Other Capcom franchises received updates or reveals

Alright, that concludes the September Edition of “This Month of Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in October!

This Month for Pythonistas - August 2025

Zeyang Lin — Sun, 31 Aug 2025 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2025 8

Welcome back Pythonistas! I’m glad to see you back reading the sixth issue of my “This month for Pythonistas” series which curates the news, articles, tutorials, podcasts, and more Python stuff worth noting in this month.

Before we continue, please note that this blog is synced across several platforms:

Ready? Let’s get started!

Python: The Documentary | An origin story is available on Youtube now.

New Versions

Python 3.13.7

Python 3.13.7 is an expedited release which aims to fix a significant issue with the 3.13.6 release:

gh-137583: Regression in ssl module between 3.13.5 and 3.13.6: reading from a TLS-encrypted connection blocks

The official downloads are available here.

Python 3.14 RC2

This is the penultimate release candidate of Python 3.14.

RC2 was originally planned as the final Release Candidate, but a bug was discovered and a third RC is scheduled in September, before October’s 3.14 final release.

The official downloads are available here.

Tutorials

DeepLearning.ai’s Claude Code: A Highly Agentic Coding Assistant from Anthropic

In this course, you’ll learn best practices for using Claude Code to improve your coding workflow. You’ll learn key tips on how to provide Claude Code with clear context, such as specifying the relevant files, clearly defining the features and functionality, and connecting Claude Code to MCP servers.

DeepLearning.ai’s Agentic Knowledge Graph Construction from neo4j

You’ll implement an agentic system using Google’s Agent Development Kit (ADK), to build a knowledge graph that helps you find the root cause of product issues. You’ll work with structured data consisting of product and supplier information, and unstructured data consisting of product reviews.

Coursera’s Fast Prototyping of GenAI Apps with Streamlit

Build and iterate GenAI apps in hours instead of days! Start with a simple chatbot, then add prompt engineering and RAG powered by Snowflake’s secure data and LLM services, then push your prototype to Snowflake or Streamlit Community Cloud for instant feedback and quick improvement.

RealPython’s AsyncIO Python

In this tutorial, you’ll learn how Python asyncio works, how to define and run coroutines, and when to use asynchronous programming for better performance in applications that perform I/O-bound tasks.

RealPython’s What Are Mixin Classes in Python?

Mixins offer a powerful way to reuse code across multiple Python classes without forcing them into a rigid inheritance hierarchy. Instead of building deep and brittle class trees, you can use mixins to share common behaviors in a modular and flexible way.

Articles

How Python Grew From a Language to a Community

Python’s growth from a programming language to a thriving community represents an inspiring story of collaboration and dedication. Starting in 1991, Python began as a pet project by Guido van Rossum, distributed through Usenet newsgroups. The pivotal moment came in 1994 with an in-person meeting of 20 developers in Maryland, where the Python community was born as something separate from the language itself.

The journey from these humble beginnings to becoming the world’s #1 programming language involved several key phases. Early attempts to commercialize Python through a consortium model failed, but the passion and commitment of its community led to the creation of the nonprofit Python Software Foundation in 2001. This foundation, guided by open-source principles, employed Python’s core team to work full-time on the language.

PyCon conferences became the “real engine for change”, generating revenue through sponsorships from tech giants like Google. This funding enabled the foundation to hire professional staff and support ongoing development and infrastructure projects. The foundation’s commitment to diversity and heterogeneous cultures positioned Python to capitalize on emerging trends like AI, ensuring its continued relevance and growth in the tech landscape.

The State of Python 2025

The article summarizes key findings from the 2025 Python Developers Survey, highlighting major trends in the Python ecosystem. It notes that 86% of respondents use Python as their main language, emphasizing its central role. Importantly, 50% of developers have less than two years of professional coding experience, and 39% have less than two years with Python. This underscores Python’s popularity among beginners and the importance of supporting newcomers with detailed tutorials and resources. The insights are based on over 30,000 responses and aim to guide both individual developers and tool vendors.

pyx: a Python-native package registry, now in Beta

Astral.sh’s ambition to build Python’s next-gen infrastructure (the Astral Platform) begins with pyx, a “Python-native package registry” which could be seen as an optimized backend for tools like uv. Some of its early partners are already using it while other have to submit their information to be on the waitlist.

Inside HRT’s Python Fork: Leveraging PEP 690 for Faster Import

HRT implemented “lazy imports” by forking CPython, using Meta’s Cinder patches. This defers module loading until first use, solving import overhead in their Python monorepo. After migration challenges (2023-2024), all HRT Python now uses lazy imports by default, cutting CLI startup times and distributed compute overhead dramatically.

How Your Code Runs in a JIT Build

This post explains how JIT compilation works in Python, focusing on CPython’s Tier 2 and Tier 3 optimizations. It covers bytecode evolution, how code transforms from Tier 1 basic bytecode through Tier 2 micro-ops to Tier 3 machine code, the role of specializations for common patterns, and how JIT bridges Python’s flexibility with C-like performance through runtime optimization based on actual execution patterns.

asyncio: a library with too many sharp corners

The article criticizes Python’s asyncio library and suggests that it is “too many sharp corners”. It details four major problems: cancellation is broken (edge-triggered vs level-triggered), tasks can be garbage collected while pending due to weak references, I/O APIs are convoluted callback-based systems inherited from Twisted, and asyncio.Queue has poor backpressure handling. Additional issues include thread integration problems, signal handling limitations, and broken eager tasks. The author recommends using Trio or AnyIO libraries instead, which implement cancellation properly with level-triggered semantics and saner I/O abstractions.

From Async/Await to Virtual Threads

In this post Armin Ronacher explores the concept of virtual threads and structured concurrency as a way to simplify concurrent programming, especially in Python. It contrasts traditional async/await models with the idea of virtual threads managed in thread groups, where parallel tasks are spawned and automatically managed with cancellation and error propagation.

Agentic Coding Things That Didn’t Work

This is another post from Armin Ronacher in which Armin discusses various approaches and tools to improve workflow automation with LLMs but found ineffective. It is highlighted that clear, manual instruction often outperforms elaborate automations. They caution that over-reliance on automation leads to mental disengagement and reduced code quality, emphasizing the importance of active review and critical thinking.

AI Agent Design Patterns: How to Build Reliable AI Agent Architecture for Production

The article emphasizes that building reliable AI agents requires more than prompt engineering—it needs modular, role-based design, observability, and feedback loops. Modular design assigns specialized roles to agents, making systems scalable and easier to maintain. Observability involves monitoring and logging every step for improvement. Feedback loops enable agents to learn and self-optimize.

Best Practices for Building Agentic AI Systems: What Actually Works in Production

The article outlines proven best practices for building productive agentic AI systems based on real-world implementation at UserJot. Key insights include using a simple two-tier architecture (primary agent + specialized subagents), keeping subagents stateless for predictability, and employing task decomposition (vertical for sequential tasks, horizontal for parallel processing). The system emphasizes structured communication protocols, parallel execution for performance, and robust error handling with graceful degradation.

Building MCP PyExec: Secure Python Execution Server with Docker & Authentication

The blog details building MCP PyExec, a secure Python execution server using the Model Context Protocol (MCP). It covers three components: the PyExec server implementing MCP for streaming Python code execution; an OAuth 2.0 Identity Provider (IDP) for secure authentication supporting authorization code flow, JWT, and token validation; and a PyExec client for testing and interaction that manages OAuth tokens and streaming results.

Introducing gpt-oss

OpenAI has released their first open-weight models since GPT-2 - gpt-oss-120b and gpt-oss-20b - under Apache 2.0 license.

Why Observability Isn’t Just for SREs (and How Devs Can Get Started)

This blog post serves as a guide for developers to understand the importance of observability and provides a playbook for integrating it into their workflow. Observability helps developers maintain cleaner code, manage systems better, and reduce technical debt by considering more edge cases and improving debugging processes.

Vibe code is legacy code

This blog highlights that vibe coding quickly generates tech debt as the produced code often becomes legacy code—difficult to understand or maintain. Vibe coding works well for prototypes and throwaway projects but is risky for large, maintainable systems, especially if done by non-programmers. Serious coding with AI requires caution, thorough understanding, and careful maintenance. The author emphasizes that while AI changes programming, deep technical knowledge and theory-building remain essential.

Podcasts

🥝 core.py

Episode 25: A Python That Never Was

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

VS Code Insiders Podcast

Repositories

jd-opensource/oxygent (Apache 2.0)

OxyGent is an open-source Python framework from JD retail department for building production-ready multi-agent AI systems. It provides modular components that snap together like LEGO bricks, enabling efficient development of collaborative AI agents. Features include intelligent real-time task decomposition, elastic distributed architecture, continuous learning capabilities, and standardized tools/LLM integration.

You can find more at their project website.

google/langextract (Apache 2.0)

LangExtract is a Python library by Google that uses LLMs to extract structured data from unstructured text. Key features include precise source grounding (mapping extractions to exact source locations), optimized handling of long documents via chunking and parallel processing, interactive HTML visualization, and support for cloud models like Gemini and local LLMs via Ollama.

nottelabs/notte (Server Side Public License 1.0)

Notte is an open-source web automation framework for building reliable AI agents. It provides essential tools for creating and deploying agents that interact with the web, combining AI reasoning with traditional scripting for cost-efficiency. Key features include structured data extraction, vaults for credential management, stealth browser sessions with CAPTCHA solving, and hybrid workflows.

langdiff (Apache 2.0)

…

mcp-use (MIT)

This is a Python library that provides a simple way to connect any LLM to any MCP server and build custom MCP agents that have tool access, without using closed source or application clients.

openai/gpt-oss (Apache 2.0)

This is the repository as part of OpenAI’s GPT-OSS, which provides a set of code implementations including a gpt-oss Python library, harmony, and more.

KittenTTS (Apache 2.0)

This is the accompanying Python library for KittenTTS, an open-source realistic text-to-speech model with just 15 million parameters which can run without a GPU.

Have time for some fun?

GamesCom 2025

Hollow Knight Silk Song finally has revealed its launch date: Sept. 4, 2025.
Resident Evil Requiem debuts a cinematic trailer featuring Grace Ashcroft for the sequel to the critically acclaimed survival horror game franchise.
Black Myth: Zhong Kui introduces Zhong Kui, a legendary demon-slayer from Chinese folklore, as the central figure of the sequel to hit Black Myth: Wukong.
Warhammer 40K Dawn of War IV is officially announced.
Lords of the Fallen II takes place a century after its predecessor, featuring faster and more punishing combat.
LEGO Batman: Legacy of the Dark Knight covers the story of Batman, starting from a young Bruce Wayne.

Alright, that concludes August Edition of “This Month of Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in September!

This Month for Pythonistas - July 2025

Zeyang Lin — Thu, 31 Jul 2025 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2025 7

Welcome back Pythonistas! I hope you enjoy your summer vacation if you actually have one. But in any case I’m glad to see you back reading the fifth issue of my “This month for Pythonistas” series which curates the news, articles, tutorials, podcasts, and more Python stuff worth noting in this month.

Before we continue, please note that this blog is synced across several platforms:

Ready? Let’s get started!

EuroPython 2025 took place in Prague again this year. For those of you who did not attend, there’s no official recordings of the talks yet.

New Versions

Python 3.14.0 release candidate 1

The first release candidate of Python 3.14 is ready! Source code as well as binary distributions can be found here.

The second candidate (and the last planned release preview) is scheduled for Tuesday, 2025-08-26, while the official release of 3.14.0 is scheduled for Tuesday, 2025-10-07.

Tutorials

Deeplearning.ai’s Post-training of LLMs from NexusFlow

In this course, you’ll learn three common post-training methods—Supervised Fine-Tuning (SFT), Direct Preference Optimization (DPO), and Online Reinforcement Learning (RL)—and how to use each one effectively.

Deeplearning.ai’s Pydantic for LLM Workflows

Use Pydantic to generate structured outputs from LLMs, ensuring the responses follow a specific format that your application can reliably process.

Articles

How global variables work in Python bytecode

The blog post explains how global variables work in Python bytecode using the Memphis interpreter built in Rust as an example. It highlights that while the VM doesn’t store the names of local variables, it performs dynamic name resolution for global variables, a key aspect of Python’s flexibility.

Python Backstage • Disassembling Python Code Using the dis Module

This article explains how to use Python’s dis module to view the bytecode generated from a simple script. The bytecode is a low-level representation of the Python code, showing the sequence of operations the Python interpreter performs. For example, the LOAD_CONST and STORE_NAME instructions represent assigning a constant value to a variable, while the CALL instruction indicates a function call.

330× faster: Four different ways to speed up your code

The article discusses four ways to accelerate Python code: efficiency improvements by reducing unnecessary calculations, using compilation to optimize performance, leveraging parallelism with multiple CPU cores, and adopting development processes like benchmarking and testing. An example analyzing letter frequency in Jane Austen’s Northanger Abbey demonstrates how combining these methods yields significant speedups, ultimately achieving a 330× faster performance.

The Missing Manual for Signals: State Management for Python Developers

The article discusses state management using Signals in Python, highlighting their benefits in handling complex state dependencies and cascading updates. It contrasts Signals with traditional manual approaches, which can lead to bugs and maintenance challenges due to implicit dependencies.

Reflections on 2 years of CPython’s JIT Compiler: The good, the bad, the ugly

This blog post discusses the current state of CPython’s JIT (Just-In-Time) compiler. The author highlights that while the JIT is still experimental and not always faster than the interpreter, a growing community of contributors is working on improving it. Key areas for improvement include performance and coverage.

Getting extensions to work with free-threaded Python

The addition of free-threaded Python allows for better thread scalability, particularly in Python extensions like NumPy. Nathan Goldbaum and Lysandros Nikolaou presented at PyCon US 2025 about the challenges and solutions for migrating the Python ecosystem to support the new free-threaded model, emphasizing the importance of maintaining compatibility with existing C/C++/Rust-based extensions.

Tools: Code Is All You Need

The author details a method for converting a blog from reStructuredText to Markdown, using an LLM to generate and validate scripts, emphasizing the importance of trust in the automated process. It concludes that while MCP may be useful for certain tasks, it currently faces limitations in composability and context management compared to direct code generation.

Wasm-agents: AI agents running in your browser

The article introduces Wasm-agents, a blueprint for creating AI agents that can run directly in your browser. These agents are packaged as standalone HTML files, utilizing WebAssembly and Pyodide to execute Python scripts and libraries.

Learnings from building AI agents

The article discusses lessons learned from developing an AI code review agent at Cubic. Initially, the tool was too noisy, generating many false positives and irrelevant comments. Improvements included requiring the AI to explicitly justify its findings, simplifying the toolset to essential components, and employing specialized micro-agents for different tasks. These changes reduced false positives by 51%, improved developer trust, and streamlined the code review process.

A Guide For LLM-Assisted Web Research

The article reviews various LLMs and web research tools for internet-based research tasks. Overall, standard ChatGPT with web search is recommended for its speed, manageability, and iterative capabilities, while more complex, slower tools are less practical for routine research tasks.

Context Engineering

This article discusses “context engineering”, which involves providing the right information to agents (like LLMs) within their context window to help them perform tasks effectively. It covers four strategies: write, select, compress, and isolate.

Programming as Theory Building: Why Senior Developers Are More Valuable Than Ever

The article discusses Peter Naur’s 1985 idea that programming is about building a shared theory of how a system works. Source code is just a representation, and critical knowledge is in developers’ minds. Today’s AI tools and novice developers risk losing this underlying theory, leading to incoherent code and technical debt. Senior developers are now more vital than ever because they preserve and evaluate the theoretical framework, ensuring system coherence and understanding the “why” behind code decisions.

Writing Code Was Never The Bottleneck

The article argues that while the creation of code may be sped up by tools like LLMs, the true bottlenecks in software engineering lie in code reviews, testing, debugging, coordination, and communication. These processes, which require deep understanding and collaboration, remain critical and cannot be bypassed.

Podcasts

🥝 core.py

The Megahertz

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

Repositories

huggingface/screenenv

blog -> ScreenEnv: Deploy your full stack Desktop Agent

google-gemini/genai-processors

blog -> Announcing GenAI Processors: Build powerful and flexible Gemini applications

Alright, that concludes the fifth issue of “This Month of Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful, and see you in August!

This Month for Pythonistas - June 2025

Zeyang Lin — Mon, 30 Jun 2025 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2025 6

Welcome back! Summer is really here and I hope you all enjoy the heat or rain. I’m glad to see you back reading the fourth issue of my “This month for Pythonistas” series which curates the news, articles, tutorials and more Python stuff worth noting in this month.

Before we continue, please note that this blog is synced across several platforms:

Ready? Let’s get started!

DjangoCon US 2025 is coming this September in Chicago, United States. The in-person tickets are officially on sale now. You can also choose to attend online with even Sprints options available.

New versions

Python 3.14.0 beta 3

The third beta release of 3.14 is here! Source code as well as binary distributions can be found here.

Python 3.13.5

Python 3.13.4 was an expected release early this month but was found to be having bugs. So another bugfix release 3.13.5 is out soon after.

Python 3.12.11, 3.11.13, 3.10.18 and 3.9.23

These are regular security releases with only offical tarball distributions. And remember that Python 3.9 is going to reach its end of life this October.

Tutorials

Deeplearning.ai’s DSPy: Build and Optimize Agentic Apps from DataBricks

This course teaches you how to use DSPy to build and optimize LLM-powered applications. You’ll write programs using DSPy’s signature-based programming model, debug them with MLflow tracing, and automatically improve their accuracy with DSPy Optimizer. Along the way, you’ll see how DSPy helps you easily switch models, manage complexity, and build agents that are both powerful and easy to maintain.

Deeplearning.ai’s Orchestrating Workflows for GenAI Applications from Astronomer

In this course, you’ll learn how to turn a Retrieval Augmented Generation (RAG) prototype into a robust, automated pipeline using Airflow 3.0, a leading open-source orchestration tool. You’ll build two workflows for a typical RAG application: one that ingests and embeds book description texts into a vector database, and another that queries that database to recommend books.

Deeplearning.ai’s Building with Llama 4 from Meta

In hands-on lessons, you’ll build apps using Llama 4’s long-context and its new multi-modal capabilities including reasoning across multiple images and “image grounding” in which you can identify elements and reason within specific image regions.

Deeplearning.ai’s ACP: Agent Communication Protocol from BeeAI and Linux Foundation

You’ll learn how to wrap an agent inside an ACP server and set up an ACP client to connect to the server. You’ll build sequential and hierarchical workflows of agents hosted inside ACP servers, and learn how to manage this workflow on the client side through a process or another agent.

RealPython’s How Can You Structure Your Python Script?

This is a comprehensive guide on structuring a standalone, shareable Python script, including specifying its dependencies in the script itself following PEP 723, handling CLI inputs, proprerly logging, and more.

Articles

PEP 734 – Multiple Interpreters in the Stdlib

PEP 734 is accepted. It proposes to add a new module, interpreters, to support inspecting, creating, and running code in multiple interpreters in the current process.

PEP 779 – Criteria for supported status for free-threaded Python

PEP 779 is accepted, which means that staring from Python 3.14 a “No-GIL” build is officially supported instead of being in “experimental” status like in Python 3.13.

How local variables work in Python bytecode

Local variables are stored on the stack, specifically within the evaluation stack of a Frame in the CallStack. Despite this, most Python variables are actually references to objects stored on the heap. The post illustrates this concept through a simple function, demonstrating how the stack changes as the function executes.

Google decided to donate Agent2Agent protocol/project to Linux Foundation

The Linux Foundation has announced the creation of the Agent2Agent (A2A) project, which aims to develop an open standard protocol that enables AI agents from different vendors to communicate, collaborate, and share information securely. Google Cloud contributed the A2A protocol specifications, SDKs, and developer tools.

How we built our multi-agent research system

This post by Anthropic gives a behind-the-scenes look at how they set up a system where multiple AI agents can work together on different tasks. Think of it like a digital teamwork lab, where AI agents can play different roles—like writers, editors, or problem-solvers—and collaborate to get things done.

The team designed the system to be super flexible, so they could easily run different types of experiments. Some agents work together on writing tasks, while others negotiate or help delegate work among themselves. It’s all about seeing how AIs interact, cooperate, and sometimes even challenge each other.

Building this wasn’t all smooth sailing—they had to deal with tricky prompts, keep experiments reproducible, and figure out how to measure how well the agents were doing. Along the way, they learned a lot: use clear building blocks, design thoughtful communication between agents, and always keep good logs.

Agentic Search for Dummies

This blog post discusses building a search agent that uses full-text search with offline document augmentation to let AI models dynamically gather context from a large document corpus. The system uses a search index (Tantivy) and a set of tools to enable a language model to issue multiple queries, fuse results, and read selected documents iteratively until it produces a final answer. The post argues against relying on dense embeddings due to complexity and overhead, advocating for full-text search as a more predictable and effective method for agentic search.

O(no) You Didn’t 😱

This article discusses the difference between theoretical Big-O performance and real-world performance, emphasizing that actual speed depends on context and profiling. Using a “Two Sum” problem as an example, it compares the brute-force O(n^2) approach with an optimized O(n) hashmap method. The article explains how memory access times and hardware factors influence performance, illustrating that understanding practical bottlenecks is crucial beyond just Big-O notation.

How to Vibe Code as a Senior Engineer

Despite concerns about AI-generated code quality, recent advancements in AI models have made vibe coding a valuable tool for experienced engineers. However, human oversight remains crucial for guiding architecture and ensuring code quality. The author emphasizes the importance of using a robust scaffold, establishing clear rules, and providing perfect context for optimal AI performance.

Will AI Replace Junior Developers? I Asked Experts at Pycon US

The blog discusses whether AI will replace junior developers, based on conversations at PyCon US. Most experts believe AI won’t fully replace programmers but will change how they work, especially in tasks like boilerplate coding. Key figures like Guido van Rossum and Trey Hunner see AI as a tool for improving productivity rather than a threat. Some, like Samuel Colvin, think AI could replace certain roles to increase efficiency.

Don’t Build Multi-Agents

The article argues against building multi-agent systems due to their fragility and context sharing challenges. It advocates for principles like sharing full context and implicit decision-making to build reliable AI agents. The author suggests simpler, single-threaded, linear agents or long-context compressed systems for better reliability.

Podcasts

🥝 core.py

PyCon US 2025 Recap

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

Repositories

strands-agents/sdk-python (Apache-2.0)

Strands Agents is an open source SDK introduced by AWS that simplifies the development of AI agents using a model-driven approach. It enables developers to build and run AI agents in a few lines of code, scaling from simple to complex use cases. Unlike other frameworks requiring complex workflows, Strands leverages the capabilities of advanced models to plan, chain thoughts, call tools, and reflect. You can start exploring the SDK on their documentation.

bytedance/deer-flow (MIT)

deer-flow is a Deep Research framework by byte-dance team. It aims to combine language models with specialized tools for tasks like web search, crawling, and Python code execution. You can either host your own or try their online demo.

gemini-cli (Apache-2.0)

Gemini CLI is Google’s answer to Anthropic’s Claude Code and OpenAI’s Codex, but with generous free-tier usage on Gemini-2.5-pro/flash at the moment.

mongodb/kingfisher (Apache-2.0)

Originally an internal tool from Mondodb, Kingfisher is an open-source command-line secrets scanner/validator written in Rust which has various built-in rules and runs “blazingly fast”. It provides pre-built binaries for Windows, MacOS and Linux, and you can also build it yourself from the source.

microsoft/edit (MIT)

Written in Rust, Edit is the promised open-source command line editor from Microsoft. It brings classic MS-DOS style UI to both Windows and Linux but also accommodates modern features.

Have time for some fun?

Call of Ducy: Black Ops 7 continues the stories of BO 2 and BO 6

Two Black Ops games in a row! During Xbox Games Showcase 2025, Activision reveals the seventh game in the COD sub-franchise where players will fight as David Mason in futuristic world of year 2035. It is going to launch on PC (Steam, Battle.net, XBOX PC), Xbox Series/One and PlayStation 5/4.

007 First Light is gonna tell the origin story of James Bond in 2026

IO Interactive, the developer behind Hitman 47 series, announces during State of Play that their 007 title “007 First Light”, “a thrilling narrative action-adventure game” in third person, is going to be published in 2026. It is expected to be available on all major platforms: PC (Steam / Epic), Xbox Series, PlayStation 5, as well as Nintendo Switch 2.

Alright, that concludes the fourth issue of “This Month of Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful, and see you in July!

This Month for Pythonistas - May 2025

Zeyang Lin — Fri, 30 May 2025 12:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2025 5

Welcome back! I’m glad to see you back reading the third issue of my “This month for Pythonistas” series which curates the news, articles, tutorials and more Python stuff worth noting in this May. This May witnesses several conferences, Python 3.14 Beta 1 & 2, more tooling, and more Agentic stuff.

Before we continue, please note that this blog is synced across several platforms:

Ready? Let’s get started!

PyCon US 2025

(Many of) the video recordings are available on PyCon US YouTube channel.

Microsoft Build 2025

Github Copilot Chat Extension for VS Code is going open-source.
Github Copilot coding agent is in public preview for Copilot Enterprise and Copilot Pro+ users.
Github Models is integrated at repository level.
Native MCP support is going to land in Windows 11.
xAI’s Grok 3 and Grok 3 mini are available via Azure AI Foundry.
Windows Subsystem for Linux (WSL) is fully open-sourse.
A command line text editor called “Edit” is coming to Windows 11, and its source code would be available too.

Google I/O 2025

New models - Veo 3, Imagen 4, and Flow - are announced.
Gemma-3n is dedicated to mobile and edge device use cases.
Project Mariner, Project Astra
Jules, an asynchronous coding agent, is now in public preview.
Gemini 2.5 Flash, the fastest version of Gemini, is coming this June.
Gemini 2.5 is brought to Google Search, the “AI mode” is currently open to users in United States.

Announcing the PyTorch Docathon 2025

This docathon is a hackathon-style event aimed at enhancing PyTorch documentation with the support of the community.

Python Documentary

A documentary about Python is coming. It will debut in July at EuroPython 2025 and will be available on YouTube as well.

New versions

Python 3.14.0 beta 1 and beta 2

The first and second of four planned beta releases of 3.14 are here! Source code as well as binary distributions can be found here and here.

wagtail 7.0 LTS

This is a major update and the first ever LTS release of Wagtail, which aligns with Django 5.2 LTS.

For more check their blog post Flying into a new era with Wagtail 7.0.

redis-py 6.2

This major release happened while Redis 8 is GA and the source code goes back to true open-source. Support for HGETDEL, HGETEX, and HSETEX commands are added. VectorSet commands are added as experimental features.

Tutorials

DeepLearning.ai’s LLMs as Operating Systems: Agent Memory from Letta

Learn how to build agentic memory into your applications in this short course, LLMs as Operating Systems: Agent Memory, created in partnership with Letta, and taught by its founders Charles Packer and Sarah Wooders.

DeepLearning.ai’s Building AI Voice Agents for Production

In this course, you’ll learn how to build voice agents that listen, reason, and respond naturally. You’ll follow the architecture used to create Andrew Avatar, a collaborative project between DeepLearning.AI and RealAvatar that responds to users in Andrew Ng’s voice.

DeepLearning.ai’s MCP: Build Rich-Context AI Apps with Anthropic

Explore how MCP standardizes access to tools and data for AI applications, its underlying architecture, and how it simplifies the integration of new tools and connections to external systems.

Deeplearning.ai’s Reinforcement Fine-Tuning LLMs with GRPO from Predibase

In this course, you’ll take a technical deep dive into RFT with GRPO. You’ll learn how to build reward functions that you can use in the GRPO training process to guide an LLM toward better performance on multi-step reasoning tasks.

HuggingFace’s MCP Course

In this course, you will:

📖 Study Model Context Protocol in theory, design, and practice.

🧑‍💻 Learn to use established MCP SDKs and frameworks.

💾 Share your projects and explore applications created by the community.

🏆 Participate in challenges where you will evaluate your MCP implementations against other students’.

🎓 Earn a certificate of completion by completing assignments.

RealPython’s Modern Web Automation With Python and Selenium

This tutorial introduces modern web automation using Python and Selenium, focusing on practical techniques for navigating and interacting with web pages. It explains how to navigate web pages, locate elements within the DOM, and interact with them through clicks, keystrokes, and form submissions.

RealPython’s Managing Python Projects With uv: An All-in-One Solution

uv is designed to streamline workflows by providing an all-in-one solution that integrates installation, package management, and environment setup. The guide covers how to install uv using a standalone installer or through other package managers, and demonstrates its use cases in managing complex projects.

Articles

PEP 773 – A Python Installation Manager for Windows

PEP 773 is accepted. It proposes a new Python installation manager for Windows, called PyManager. The current installation methods for Python on Windows have several limitations and challenges, including mismatched user expectations and unreliability. PyManager aims to address these issues by providing a single, unified installation management tool that can handle multiple Python versions and provide a more streamlined user experience. It will be distributed through both the Windows Store and python.org as an MSIX package.

PEP 784 – Adding Zstandard to the standard library

PEP 784 is accepted. It proposes adding a new module to the Python standard library for Zstandard compression, a widely adopted and highly efficient compression standard. It aims to provide a unified interface for compression modules, reduce user confusion, and enable future additions of new compression formats. The reference implementation is based on the pyzstd project and includes integration with tarfile, shutil, and zipfile modules.

Unravelling t-strings

T-strings expose the parser used for f-strings, allowing introspection of the parts inside the curly braces. Brett demonstrates how to replicate f-string behavior using Python code to parse and format the components (value, conversion, and format spec) of t-strings. This parsing helps understand how expressions inside f-strings are evaluated and formatted internally.

Python Tooling at Scale: LlamaIndex’s Monorepo Overhaul

Llama-index managed to contain 650+ community packages in their monorepo. They migrated away from Poetry and Pants to uv and LlamaDev for faster, simpler development.

Pyrefly vs. ty: Comparing Python’s Two New Rust-Based Type Checkers

Both pyrefly and ty are promising new type checkers that aim to improve the Python type checking experience. While they share some similarities, they have different design goals and philosophies. ty takes a gradual approach to typing, while pyrefly is more aggressive in type inference. As both tools are still in early alpha, it will be interesting to see how they evolve in the future.

Takeaways from DjangoCon EU 2025

The article summarizes key takeaways from DjangoCon EU 2025 in Dublin, highlighting the community’s enthusiasm and valuable technical insights. Topics include database management techniques such as row locking with select_for_update, moving to BigInt primary keys, and partitioning large tables for performance. It also covers optimization strategies like reducing PostgreSQL index sizes significantly by using partial indexes.

PyTorch: The Open Language of AI

PyTorch has evolved from a framework focused on AI research to supporting production, deep AI compilation and has become foundational to thousands of projects and companies in the AI ecosystem. The PyTorch Foundation is expanding to be an umbrella organization and will now house some of the most popular and highly complementary projects making it easier for users to build AI at scale.

The first year of free-threaded Python

The first year of free-threaded Python has seen significant progress in enabling Python to fully utilize multicore CPUs and GPUs by removing the Global Interpreter Lock (GIL). Major packages and tools like NumPy, SciPy, Cython, and setuptools have been updated to support the free-threaded build. While many packages still require auditing and fixes for thread safety, the ecosystem has improved considerably.

Asyncio Demystified: Rebuilding it From Scratch One Yield at a Time

The article demystifies asyncio by rebuilding it from scratch. It starts with a primer on generators and coroutines, explaining how they can pause and resume execution. The article builds a custom event loop, showcasing an echo server example. The goal is to understand how asyncio works under the hood, removing the “magic” behind asynchronous programming in Python.

MCP explained without hype or fluff

The author shares a concrete example of an MCP server built for accessing CKAN open data, enabling AI applications to explore and analyze government datasets. Despite MCP’s evolving nature and some overhead, its adoption is strong, providing a standardized way to decouple AI clients from platform-specific tools and workflows, valuable for integrations requiring flexibility and breadth.

MCP is a powerful new AI coding technology: Understand the risks

While MCP offers powerful capabilities, it poses significant security risks because it is not secure by default. Experts warn that deploying MCP in production environments without robust safeguards is risky. However, ongoing efforts from industry and security researchers aim to enhance MCP’s security, making it a promising but still maturing technology.

A Critical Look at MCP

The author argues that the protocol’s documentation is poorly written, confusing, and glosses over important aspects. The author also criticizes the use of Python and JavaScript for examples, and the complexity of the protocol’s multiple transport modes, including HTTP+SSE and “Streamable HTTP”. It is suggested that WebSockets would be a better choice for transport, and that the protocol’s flexibility introduces security concerns and complexity. The author also mentions alternative protocols, such as ACP and A2A.

Claude Opus 4 and Claude Sonnet 4

Claude 4 Opus leads in complex, sustained coding tasks, excelling in memory usage and long-term focus, while Claude 4 Sonnet offers balanced performance and efficiency for everyday use, particularly powering GitHub Copilot. Both models support extended thinking with tool use, improved memory for handling local files, and parallel tool execution.

Podcasts

🥝 core.py

Episode 22: Beta Frenzy

DjangoChat

DjangoCon Europe 2025 Recap

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

Repositories

facebook/pyrefly (MIT)

One of the tools I mentioned earlier. pyrefly is Meta’s brand new type checker for Python at very ealy stage. Read more about it on Facebook Engineering.

astral-sh/ty (MIT)

The other tool I mentioned earlier. Powered by Rust, ty is Astral’s standalone static type checker for Python but developed as part of ruff, previously known as “Red-Knot”. It comes with a command-line utility as well as a VS Code extension.

microsoft/magentic-ui (MIT)

Magentic-UI is a research prototype of a human-centered interface powered by a multi-agent system that can browse and perform actions on the web, generate and execute code, and generate and analyze files. Magentic-UI is built using AutoGen and provides a platform to study human-agent interaction and experiment with web agents.

Have time for some fun?

Gears of War: Reloaded Comes to Xbox Series, PlayStation 5 and Steam this August

This is a Remastered version of the first ever game in its franchise, featuring 4K/60FPS in the Campaign with HDR, Dolby Atmos, cross-platform play, etc. Those who own the digital version of Gears of War: Ultimate Edition would receive a free upgrade to Gears of War: Reloaded.

This Month for Pythonistas - April 2025

Zeyang Lin — Wed, 30 Apr 2025 07:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2025 4

Welcome back and I’m glad to see you back reading the second issue of my “This month for Pythonistas” series which curates the news, articles, tutorials and more Python stuff worth noting in this April.

Before we continue, please note that this blog is synced across several platforms:

Ready? Let’s get started!

DjangoCon Europe 2025

Dublin, Ireland is the host city of this year’s DjangoCon Europe, which is held from April 23rd to 27th, 2025.

djangocon europe website

EuroPython 2025

EuroPython has announced three more Keynote Speakers: Sebastián Ramírez (Creator os FastAPI, Typer, SQLModel, etc.), Brett Cannon (Python Core Developer), and Petr Baudiš (co-founder and CTO of Rossum).

Besides, EuroPython will have a booth at PyCon US this year.

Microsoft turns 50

Like it or not, Microsoft had remarkable influence over the past decades and is still making a big impact right at the moment. In this page it celebrates its 50th anniversary by looking back at some iconic moments from the history, sharing some stories, and giving out digital goodies.

Discord server for free-threaded Python

There is a dedicated place to discuss free-threaded python on Discord now.

GvR BDFL (🤡 April Fools 🤡)

BREAKING! Guido van Rossum, the legendary creator of Python, has officially reinstated himself as Benevolent Dictator for Life (BDFL).

New versions

Python 3.13.3 & 3.12.10

It’s another month for Python version updates.

Python 3.14 Alpha 7 is out, and the first beta release is expected soon.

Python 3.13 and 3.12 receive bugfix updates:

The following versions receive only security-related fixes and no binary distributions are provided: 3.11.12, 3.10.17 and 3.9.22.

Visual Studio Code 1.99.0

VS Code joins Claude Desktop and other “AI IDEs”, having Agent Mode and MCP servers support (Preview).

A new open-source and local MCP server is introduced, allowing integration with any LLM tool supporting MCP. Read the details in Vibe coding with GitHub Copilot: Agent mode and MCP support rolling out to all VS Code users.

Update: Agent Mode is now officially turned on for everyone.

Django 5.2 LTS

This LTS version introduces new features (Automatic model imports in the shell, Composite primary keys, etc.) and deprecates some functionalities, and it will receive security updates for the next three years at least. Check its release notes.

PyTorch 2.7

This release introduces support for NVIDIA’s new Blackwell GPU architecture and ships pre-built wheels for CUDA 12.8. TorchAudio is updated to 2.7.0 and TorchVision is 0.22.0.

Ubuntu 25.04, Fedora 42, MX 23.6 and Manjaro 25.0

It seems like a big month for Linux distros since several popular distro have major/minor updates:

Ubuntu 25.04 “Plucky Puffin” introduces Linux 6.14 kernel, GNOME 48, and offers 9 months of support.
Fedora 42 promotes KDE Plasma variation to “Full Edition”.
MX Linux is a regular refresh containing bugfixes, kernel updates, and application updates.
Manjaro 25.0 “Zetar” brings various updates to different desktop environment editions.

Tutorials

Deeplearning.ai’s Vibe Coding 101 with Replit from replit

Take your own discretion on “Vibe Coding” (there’s an article about it below), but here’s a hands-on tutorial on deeplearning.ai.

You’ll use Replit’s cloud environment— with an integrated code editor, package manager, and deployment tools—to build and deploy two web applications with the help of an AI coding agent. Along the way, you’ll learn strategies for working effectively with agents and improve your development skills in the process.

Deeplearning.ai’s Getting Structured LLM Output from DotTxt

You’ll gain a fundamental understanding of structured outputs and learn efficient ways to generate outputs in your defined schema or format.

Deeplearning.ai’s Building AI Browser Agents from AGI Inc.

Learn the fundamentals of autonomous web agents, what they are, how they work, their limitations, and the decision-making strategies taken to optimize their performance.

Deeplearning.ai’s Building Code Agents with Hugging Face smolagents from HuggingFace

Understand the architecture and benefits of code agents that write code to perform tasks, compare them to traditional tool-calling agents, and learn when to use each approach.

RealPython’s Introducing DuckDB

The tutorial will equip you with the practical knowledge necessary to get started with DuckDB, including its Online Analytical Processing (OLAP) features, which enable fast access to data through query optimization and buffering.

freeCodeCamp.org’s Code DeepSeek V3 From Scratch in Python

This is a nearly-4-hours Youtube video tutorial brought by freeCodeCamp.

HuggingFace’s Agents Course

A series of tutorials introducing various aspects of AI Agents.

Articles

Python’s new t-strings

PEP 750 – Template Strings is accepted. This PEP introduces template strings which are a generalization of f-strings. Putting a t before a string template would keep it from being evaluated as a normal string but make it an instance of a new type Template.

In his blog, Dave introduces the motivation behind this PEP and shows how to play with it.

PEP 751 – A file format to record Python dependencies for installation reproducibility

PEP 751 is accepted. This PEP proposes a standard for the format of a file recording the requirements/dependencies of a Python project (ie. a lock file but standardized, agreed across the whole community).

Update:

pip 25.1+ adds experimental pip lock command:

pip lock -r .\requirements.txt --output pylock.toml

uv 0.6.15+ adds support through uv export command:

uv export --format pylock.toml --output-file pylock.toml

pdm 2.24+ also supports exporting to pylock.toml:

pdm export --format pylock --output pylock.toml

Share Python Scripts Like a Pro: uv and PEP 723 for Easy Deployment

Sharing single-file Python scripts with external dependencies is now easy thanks to uv and PEP 723, which enable embedding dependency metadata directly within scripts.

Case Study: Developing and Testing Python Packages with uv

This article highlights the simplicity of initializing a project with uv, which sets up essential files like pyproject.toml, README.md, and folder structures. This allows developers to manage dependencies effortlessly and set up virtual environments. It emphasizes the convenience of editable installations, enabling instant updates to package code without needing reinstallation.

The Llama 4 herd: The beginning of a new era of natively multimodal AI innovation

Meta has introduced Llama 4, its latest suite of multimodal AI models including “Llama 4 Scout” and “Llama 4 Maverick”, offering significant advancements in personalized AI experiences. Both models utilize a mixture-of-experts (MoE) architecture, allowing efficient use of parameters: Maverick has 17 billion active parameters with 128 experts, while Scout offers a remarkable context length of 10 million tokens. “Llama 4 Behemoth”, a larger model with 288 billion parameters, serves as a teacher for the others, enhancing their capabilities.

Agent Development Kit: Making it easy to build multi-agent applications

Google brings its own agent-building solution by announcing open-source framework Agent Development Kit (ADK) at Google Cloud NEXT 2025, additionally it introduces Agent2Agent (A2A) protocol, Agent Engine as well as Agent Garden.

Introducing GPT-4.1 in the API

GPT‑4.1, GPT‑4.1 mini, and GPT‑4.1 nano are available through OpenAI’s API service. These new models appear to focus mainly on coding and instruction following.

Update: They are also available through Github Models.

Introducing OpenAI o3 and o4-mini

OpenAI then release o3 and o4-mini of the o-series models, claiming they are their “smartest” models to date.

The role of developer skills in agentic coding

This article discusses the role of developer skills in agentic coding with AI assistants. The author categorizes AI missteps into three impact radius: time to commit, team flow, and long-term maintainability. The article emphasizes the need for developer oversight, caution against “good enough” solutions, and the importance of code quality practices and team communication.

MCP (Model Context Protocol): Simply explained in 5 minutes

Model Context Protocol is a way for LLMs to integrate with external tools. It is useful as it makes LLMs act more like developers. Behind the scenes, providers create MCP-compliant wrappers. Resources for MCP are also provided.

MCP - It’s Hot, But Will It Win?

In the author’s point of view, while MCP is popular, its success is uncertain. Middleware like MCP often fails to live up to expectations. It may face issues such as monetization problems if widely adopted or exclusion by a key platform. Vendors may lose interest due to market realities.

The “S” in MCP stands for Security

Despite its benefits, such as standardized APIs and persistent sessions, MCP has significant security risks. These risks include potential side-channels into shells, secrets, or infrastructure when agents are connected to arbitrary servers without proper security measures. The author emphasizes the need for better security in MCP to prevent these vulnerabilities.

MCP vs. A2A: Friends or Foes?

MCP standardizes how applications integrate with large language models (LLMs), while A2A facilitates communication between agents across different systems. Although MCP currently excels in establishing context for LLMs, it lacks essential features like security and task management, which A2A addresses. As both protocols evolve, their roles may intertwine, but A2A appears poised for dominance in inter-agent communication, potentially overshadowing MCP’s relevance in the future.

Git turns 20: A Q&A with Linus Torvalds

To celebrate two decades of Git, the author sat down with Linus himself to revisit those early days, explore the key design decisions behind Git’s lasting success, and discuss how it forever changed software development. The full video interview is also included in the blog.

Karpathy’s ‘Vibe Coding’ Movement Considered Harmful

The author argues that Karpathy’s “vibe coding” is harmful. It leads to hidden costs, exponential technical debt, and security risks. A better approach is to use AI with a clear vision, break down AI-generated code, provide context, test thoroughly, and review code to maintain understanding.

Training and Finetuning Reranker Models with Sentence Transformers v4

In this blogpost, the author shows how to use sentence-transformers to finetune a reranker model that beats all existing options on exactly your data. This method can also train extremely strong new reranker models from scratch.

Podcasts

🥝 core.py

Episode 21: A Garbage Episode

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

Repositories

Have time for some fun?

Nintendo Switch 2 has a launch date

Nintendo reveals in their “Direct” livestream event that Switch 2 is available on June 5th, 2025 worldwide with starting price ~$449.99 outside Japan (multi-language version) and a much lower price inside Japan (Japanese-only version). Read more about it on their official website.

Clair Obscur: Expedition 33 sets sail on April 24th

In this dark fantasy RPG inspired by JRPG and Soul-like games and made by a small French team “Sandfall Interactive”, players will explore the mysterious city of Lumière and engage in immersive turn-based battles with unique mechanics. After playing it for around 30 hours I must say I really enjoyed the visual style and the rewarding action part in the battles. Check their official website for more info.

Alright, that concludes the second issue of “This Month of Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful, and see you in May!

This Month for Pythonistas - March 2025

Zeyang Lin — Mon, 31 Mar 2025 07:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2025 3

Welcome and thank you for reading This Month for Pythonistas, a monthly update dedicated to Python developers, professionals, and hobbyists.

In this inaugural issue, I would like to compile a list of news, articles, repositories, and tools worth noting in March 2025, as well as other fun stuff that may not necessarily be bound to Python community.

Before we continue, please note that this blog is synced across several platforms:

Ready? Let’s get started!

EuroPython 2025 Updates

EuroPython 2025 stays in Prague, Czech Republic (which makes Prague the host city three years in a row!), and the ticket sales start this month.

Python Core Developer Savannah Ostrowski is going to be one of the keynote speakers this year.

Get to know more in their blog.

New versions

`ipython` 9.0.2

The first major version update in three years! Check it out on pypi.

`dify` v1.1.3

This major update (v1) brings a plugin system, a new Agent node in workflow, “Extenstion”, “Dify Marketplace”, and more!

Check this particular release on github.

Tutorials

Deeplearning.ai’s Event-Driven Agentic Document Workflows from LlamaIndex

Build an event-driven agentic workflow that parses forms, retrieves relevant information from a source document using RAG, and returns answers to the form’s fields as structured outputs.

Deeplearning.ai’s Long-Term Agentic Memory with LangGraph from LangChain

Build a personal email agent with routing, writing, scheduling tools to automatically ignore, respond to, or notify about incoming emails.

RealPython’s LangGraph: Build Stateful AI Agents in Python

Here is another tutorial regarding LangGraph.

Explore the full tutorial to gain hands-on experience with LangGraph, including setting up workflows and building a LangGraph agent that can autonomously parse emails, send emails, and interact with API services.

RealPython’s Python’s Instance, Class, and Static Methods Demystified

Instance, class, and static methods each serve a distinct role in Python, and knowing when to use one over another is key to writing clean, maintainable code. Instance methods operate on individual objects using self, while class methods use cls to access class-level data. Static methods, on the other hand, provide organizational structure without relying on class or instance state.

RealPython’s Python Code Quality: Best Practices and Tools

In this tutorial, you’ll learn about code quality and the key factors that make Python code high-quality. You’ll explore effective strategies, powerful tools, and best practices to elevate your code to the next level.

Articles

Performance of the Python 3.14 tail-call interpreter

The CPython project’s new tail-call interpreter initially showed a 10 - 15% performance boost. However, the author found this was mainly due to an LLVM 19 regression. When benchmarked against better baselines, the gain dropped to 1 - 5%. The LLVM 19 regression affected the bytecode interpreter’s optimization. Also, the “computed goto” approach might be unnecessary for modern Clang.

New tools for building agents

OpenAI introduces their new approach on building agents systems: the new Responses API which would replace Assistants API, a new Python SDK as a agents framework, and more.

Google’s Gemma 3

Latest iteration of Google’s open-weight LLM includes four sizes from small to medium: 1B, 4B, 12B, and 27B. Here’s the technical report.

Mistral Small 3.1

Mistral releases its newest “small” (24B) multi-modal, multilingual LLM, claiming it “outperforms comparable models like Gemma 3 and GPT-4o Mini, while delivering inference speeds of 150 tokens per second”.

Its “instruct” variation’s weight is obtainable from HuggingFace.

A Deep Dive Into MCP and the Future of AI Tooling

This article delves into the Model Context Protocol (MCP), an open protocol aiming to standardize AI model interactions with tools. Inspired by LSP, MCP supports autonomous AI workflows and human-in-the-loop operations. It has various use cases in dev-centric workflows and net-new experiences. However, the MCP ecosystem is in its early stage, facing challenges like authentication, authorization, and server discoverability. If these issues are resolved, MCP could reshape AI-tool interactions, leading to new pricing models, hosting modes, and a shift in tool development and consumption.

Introducing KBLaM: Bringing plug-and-play external knowledge to LLMs

KBLaM is a new approach to integrate structured knowledge bases into pre-trained LLMs. Traditional methods like fine-tuning and RAG have drawbacks, and in-context learning has computational issues. KBLaM converts knowledge bases into continuous key-value vector pairs and uses rectangular attention for efficient integration. It’s scalable, with linear cost and dynamic updates. KBLaM also enhances interpretability and reliability, reducing hallucinations. It paves the way for more reliable AI systems in critical fields.

Podcasts

🥝 core.py

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

Tools

Warp on Windows

Warp is one of my favorite new toys in year 2024, and now it comes to Windows platform. Check their blog!

Cherry Studio 1.1.10

Cherry Studio catches quite a lot of eyes recently, and it just reaches 1.0 not too long ago. official download

Repositories

`lmstudio-python` (MIT)

I personally have been using LM Studio for roughly one year, and this lmstudio-python (alongside lmstudio-js for JavaScript) is their official SDK with which you can easily manage the models, conversations and more using pure Python code. They have documentations too: docs.

The source code is hosted on github.

`openai-agents-python` (MIT)

OpenAI’s latest contribution to open-source includes this framework for creating multi-agent workflows. This is also among the new toys from OpenAI which I mentioned earlier in this issue.

The source code is on github, and the documentation too.

Update: The Agents SDK has support for MCP, which means you can now connect MCP servers to Agents.

`smolagents` (Apache-2.0)

Another light-weight (“smol”) framework which helps you build AI agents, brought by the HuggingFace team.

Here’s the repostitory

`DeepSeek-V3-0324`

The is an updated version of V3, released just this March. The weights can be found on HuggingFace

`Qwen2.5-Omni-7B`

Qwen team has released their version of “omni” model on HuggingFace.

Have time for some fun?

Command & Conquer games go open-source

Despite their infamous and disastrous management on this beloved franchise, EA chose to open-source some of the classic C&C games on github, potentially enriching the Modding community support.

Here are the repositories (Mostly C++, plus some C, Assembly and others; under GNU GPL v3):

Death Stranding 2: On the Beach (finally) has a launch date

It would be on the shelves on June 26th (or 24th for Deluxe Edition owners), 2025 for Playstation only (… for a while at least), and the pre-order starts March 17th.

The price starts from 69.99 USD, 79.99 EUR, 568 HKD or 8,980 JPY.

More details can be found in this playstation blog.

StarCraft goes to tabletop

In their blog, Archon Studio announced an official partnership with Blizzard Entertainment, launching a StarCraft tabletop miniatures game in 2026, followed by board games set in the StarCraft universe in 2027.

More details, like miniature previews and gameplay mechanics, will be revealed later in 2025.

Alright, that concludes the very first issue of “This Month of Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful, and see you in April!

[one-liner] Install Ollama

Zeyang Lin — Wed, 17 Jul 2024 05:33:41 GMT

One-Liner series: Ollama

source: ollama.com

Install on Ubuntu

curl -fsSL https://ollama.com/install.sh | sudo sh

Install a specific version

curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.2.5 sudo sh

Alternative source (possibly not up-to-date with offical release)

pip install modelscope

modelscope download --model=modelscope/ollama-linux --local_dir ./ollama-linux

cd ollama-linux

chmod +x ./ollama-modelscope-install.sh

./ollama-modelscope-install.sh`

Update on Ubuntu

Run the same command as above

curl -fsSL https://ollama.com/install.sh | sudo sh

Uninstall on Ubuntu

sudo systemctl stop ollama
sudo systemctl disable ollama
sudo rm /etc/systemd/system/ollama.service

sudo rm $(which ollama)

sudo rm -r /usr/share/ollama
sudo userdel ollama
sudo groupdel ollama

UV is the latest attempt to rule All Python tools

Zeyang Lin — Wed, 21 Feb 2024 07:23:13 GMT

In short, uv is a command line tool written in Rust for Python developers, which aims to be “a comprehensive project and package manager that is extremely fast, reliable, and easy to use”.

If you are still interested, I hope you can spend a couple of minutes so that I can give you a quick tour of it.

Quick fact sheet

language: Rust

version: 0.1.13 (at the time of updating this post)

repo: github (6k stars)

pypi: pypi

docs: N/A

supported python versions: 3.8 through 3.12 (inclusive)

supported os: Windows, Linux, MacOS

Drop-in replacement for pip and more

uv is from the creator of ruff, Charlie Marsh and astralsh.

ruff, the linting and formating tool written is Rust as well, has already gain fame and popularity during the past year or so, and I believe many of Python developers have been using it for quite a while.

And uv is no doubt their next step in improving the Python toolchain eco.

Although you can easily install uv using pip or pipx just like any other Python tool, essentially it does not rely on your Python interpreter to be installed.

It provides just the binary executable and you can get it easily by running the quick script following the insructions in its git repo. And that’s it, no Python or Rust runtime required till this point.

Creating a virtual environment is now as easy as uv venv, though you now need at least one Python interpreter ready to make it work.

The virtual env it creates is just a standard Python venv, except it does not include pip by default (however if you need pip, you can let it be included by using an extra flag, or you could install it manually anytime after).

Some of your daily commands can then be like (but faster):

uv pip install -r requirements.txt
uv pip install black==24.2.0
uv pip compile pyprojects.toml -o requirements.txt

Fast in deed

Just like ruff is known as being an extremely fast linter, uv’s speed is also impressive.

Here is a short requirements.txt from one of my repos:

fastapi==0.109.2
pydantic[email]==2.6.1
python-multipart==0.0.9
uvicorn[standard]==0.27.1

coverage>=7.4.0
httpx>=0.26.0
memray>=1.11.0
pytest>=8.0.0

And I gave uv a try using github actions. The result on ubuntu-latest with Python 3.12 looks like this

> Run uv pip install -r requirements.dev.txt
Resolved 40 packages in 185ms
Downloaded 40 packages in 268ms
Installed 40 packages in 24ms
 + annotated-types==0.6.0
 + anyio==4.3.0
 + certifi==2024.2.2
 + click==8.1.7
 + coverage==7.4.2
 + dnspython==2.6.1
 + email-validator==2.1.0.post1
 + fastapi==0.109.2
 + h11==0.14.0
 + httpcore==1.0.3
 + httptools==0.6.1
 + httpx==0.26.0
 + idna==3.6
 + iniconfig==2.0.0
 + jinja2==3.1.3
 + linkify-it-py==2.0.3
 + markdown-it-py==3.0.0
 + markupsafe==2.1.5
 + mdit-py-plugins==0.4.0
 + mdurl==0.1.2
 + memray==1.11.0
 + packaging==23.2
 + pluggy==1.4.0
 + pydantic==2.6.1
 + pydantic-core==2.16.2
 + pygments==2.17.2
 + pytest==8.0.1
 + python-dotenv==1.0.1
 + python-multipart==0.0.9
 + pyyaml==6.0.1
 + rich==13.7.0
 + sniffio==1.3.0
 + starlette==0.36.3
 + textual==0.52.1
 + typing-extensions==4.9.0
 + uc-micro-py==1.0.3
 + uvicorn==0.27.1
 + uvloop==0.19.0
 + watchfiles==0.21.0
 + websockets==12.0

As you can see, this process, including solving the dependencies, downloading them and installing them, took just less than half a second!

Features in need

uv’s vision, according to the blog, is

a single binary that bootstraps your Python installation and gives you everything you need to be productive with Python, bundling not only pip, pip-tools, and virtualenv, but also pipx, tox, poetry, pyenv, ruff, and more.

And appearantly at the current point, it is still quite far away from that.

The only two major top-level sub-commands the cli currently supports are

venv
pip
cache

It thus can only create a virtual environment, install dependencies into it and outputs a “lock” file, etc.

I want it to list installed packages, or run commands using the interpreter inside the virtual env, just like what poetry is capable of right now.

Not to mention that it cannot run tests, switch virtual environments or lint source files.

But it’s still in its early age, and the pace is like one patch version every couple of days, isn’t it?

What about Rye

The ambitions of uv share a lot with those from Rye, a tool (which happens to be written in Rust as well) created by Armin Ronacher, the creator of Flask.

What’s more, the team behind uv, astralsh, is actually taking over the dev work of Rye according to their blog, and ultimately going to migrate Rye to uv in the future.

We saw this as a rare opportunity to team up, and to avoid fragmenting the Python ecosystem. As such, in collaboration with Armin, we’re excited to be taking over Rye. Our goal is to evolve uv into a production-ready “Cargo for Python”, and to provide a smooth migration path from Rye to uv when the time is right.

Some thoughts

The name uv seems not relevant to libuv, uvloop or uvicorn.

Maybe it’s short for “universal/ultimate/unified virtualenv manager”?

The dedicated docs pages of uv are not present at the time of writing, which is a pitty.

References

My First Hugo Blog

Wed, 31 Jan 2024 07:32:01 GMT

Introduction

This site is synced across:

MOJO Series #1: Install SDK on UBUNTU

Zeyang Lin — Fri, 08 Sep 2023 10:00:00 GMT

So, THAT 35000-times-faster-than-python language, mojo, released its SDK today. This means you can install Mojo in your own environment and run mojo programs.

And here in this post, I will show you how to do it on Ubuntu.

System Requirements

Ubuntu 20.04 and later
x86-64 CPU and minimum 4 GB RAM
Python 3.8 - 3.10
g++ or clang++ compiler

My environment

Kubuntu 22.04.3
AMD CPU with 16GB RAM
Python 3.10.12
g++ 11.4.0

Install steps

1. Install Modular CLI

# switch to root first
sudo -u root -i

# then run the following command
apt-get install -y apt-transport-https &&
  keyring_location=/usr/share/keyrings/modular-installer-archive-keyring.gpg &&
  curl -1sLf 'https://dl.modular.com/bBNWiLZX5igwHXeu/installer/gpg.0E4925737A3895AD.key' |  gpg --dearmor >> ${keyring_location} &&
  curl -1sLf 'https://dl.modular.com/bBNWiLZX5igwHXeu/installer/config.deb.txt?distro=debian&codename=wheezy' > /etc/apt/sources.list.d/modular-installer.list &&
  apt-get update &&
  apt-get install -y modular

# switch back to normal user
exit

2. Verify `modular` is installed

which modular

/usr/bin/modular

3. Install Mojo SDK

modular auth <YOUR AUTH KEY> && modular install mojo

# Found release for https://packages.modular.com/mojo @ 0.2.1, installing to /home/******/.modular/pkg/packages.modular.com_mojo
# Downloads complete, setting configs...
# Configs complete, running post-install hooks...

..................<OMITTED>

Successfully installed ansiwrap-0.8.4 attrs-23.1.0 certifi-2023.7.22 charset-normalizer-3.2.0 entrypoints-0.4 fastjsonschema-2.18.0 find_libpython-0.3.0 idna-3.4 jsonschema-4.19.0 jsonschema-specifications-2023.7.1 jupyter-core-5.3.1 jupyter_client-8.3.1 nbclient-0.8.0 nbformat-5.9.2 papermill-2.4.0 platformdirs-3.10.0 python-dateutil-2.8.2 pyzmq-25.1.1 referencing-0.30.2 requests-2.31.0 rpds-py-0.10.2 tenacity-8.2.3 textwrap3-0.9.2 tornado-6.3.3 tqdm-4.66.1 traitlets-5.9.0 urllib3-2.0.4
WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
Testing `MODULAR_HOME=/home/******/.modular`
* `/home/******/.modular/pkg/packages.modular.com_mojo/bin/mojo`...
TEST: `mojo --help`... OK
TEST: `mojo run --help`... OK
TEST: `mojo build test_mandelbrot.mojo`... OK
TEST: `mojo build test_python.mojo`... OK
TEST: `mojo demangle`... OK
TEST: `mojo format`... OK
TEST: `mojo package`... OK
TEST: `mojo test_mandelbrot.mojo`... OK
TEST: `mojo test_python.mojo`... OK
TEST: `mojo repl`... OK

🔥 Mojo installed! 🔥

Now run the following commands if you are using bash:

echo 'export MODULAR_HOME="/home/******/.modular"' >> ~/.bashrc
echo 'export PATH="/home/******/.modular/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

If you are using ZSH, run the following commands:

echo 'export MODULAR_HOME="/home/******/.modular"' >> ~/.zshrc
echo 'export PATH="/home/******/.modular/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

Then enter 'mojo' to start the Mojo REPL.

For tool help, enter 'mojo --help'.
For more docs, see https://docs.modular.com/mojo.

4. Add mojo to PATH

# You must replace two <USERNAME> with your own username
echo 'export MODULAR_HOME="/home/<USERNAME>/.modular"' >> ~/.bashrc

echo 'export PATH="/home/<USERNAME>/.modular/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.bashrc

source ~/.bashrc

Now verify mojo command is accesible:

which mojo

/home/******/.modular/pkg/packages.modular.com_mojo/bin/mojo

5. Mojo REPL

mojo

Welcome to Mojo! 🔥 Expressions are delimited by a blank line. Type :mojo help for further assistance.

Bonus Round: directory structure

tree $MODULAR_HOME

/home/******/.modular
├── crashdb
│   ├── attachments
│   ├── completed
│   ├── new
│   ├── pending
│   └── settings.dat
├── modular.cfg
└── pkg
    └── packages.modular.com_mojo
        ├── bin
        │   ├── lldb
        │   ├── lldb-argdumper
        │   ├── lldb-server
        │   ├── lldb-vscode
        │   ├── modular-crashpad-handler
        │   ├── mojo
        │   └── mojo-lsp-server
        ├── installed.json
        ├── jupyter
        │   ├── kernel
        │   │   ├── logo-64x64.png
        │   │   ├── logo.svg
        │   │   └── mojokernel.py
        │   └── manage_kernel.py
        ├── lib
        │   ├── libKGENCompilerRTShared.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libKGENCompilerRTShared.so.18git
        │   ├── libKGENCompilerRTShared.so.18git
        │   ├── libKGENCompilerRT-static.a
        │   ├── libLLCLRuntimeGlobals.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libLLCLRuntimeGlobals.so.18git
        │   ├── libLLCLRuntimeGlobals.so.18git
        │   ├── liblldb.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/liblldb.so.18.0.0git
        │   ├── liblldb.so.18.0.0git
        │   ├── liblldb.so.18git -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/liblldb.so.18.0.0git
        │   ├── libMojoJupyter.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libMojoJupyter.so.18git
        │   ├── libMojoJupyter.so.18git
        │   ├── libMojoLLDB.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libMojoLLDB.so.18git
        │   ├── libMojoLLDB.so.18git
        │   ├── libMSupportGlobals.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libMSupportGlobals.so.18git
        │   ├── libMSupportGlobals.so.18git
        │   ├── liborc_rt.a
        │   ├── lldb-visualizers
        │   │   ├── lldbDataFormatters.py
        │   │   └── mlirDataFormatters.py
        │   ├── mblack
        │   │   ├── base_library.zip
        │   │   ├── importlib_metadata-6.8.0.dist-info
        │   │   │   ├── INSTALLER
        │   │   │   ├── LICENSE
        │   │   │   ├── METADATA
        │   │   │   ├── RECORD
        │   │   │   ├── top_level.txt
        │   │   │   └── WHEEL
        │   │   ├── libbz2.so.1.0
        │   │   ├── libcrypto.so.1.1
        │   │   ├── lib-dynload
        │   │   │   ├── _asyncio.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _bz2.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_cn.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_hk.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_iso2022.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_jp.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_kr.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_tw.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _contextvars.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _ctypes.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _decimal.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _hashlib.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _json.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _lzma.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── mmap.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _multibytecodec.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _multiprocessing.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _opcode.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _posixshmem.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _queue.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── resource.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _ssl.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── termios.cpython-38-x86_64-linux-gnu.so
        │   │   │   └── _uuid.cpython-38-x86_64-linux-gnu.so
        │   │   ├── libexpat.so.1
        │   │   ├── libffi.so.7
        │   │   ├── liblzma.so.5
        │   │   ├── libmpdec.so.2
        │   │   ├── libpython3.8.so.1.0
        │   │   ├── libssl.so.1.1
        │   │   ├── libuuid.so.1
        │   │   ├── libz.so.1
        │   │   ├── mblack
        │   │   └── mblib2to3
        │   │       ├── Grammar.txt
        │   │       ├── __init__.py
        │   │       ├── LICENSE
        │   │       ├── PatternGrammar.txt
        │   │       ├── pgen2
        │   │       │   ├── conv.py
        │   │       │   ├── driver.py
        │   │       │   ├── grammar.py
        │   │       │   ├── __init__.py
        │   │       │   ├── literals.py
        │   │       │   ├── parse.py
        │   │       │   ├── pgen.py
        │   │       │   ├── tokenize.py
        │   │       │   └── token.py
        │   │       ├── pygram.py
        │   │       ├── pytree.py
        │   │       └── README
        │   ├── mojo
        │   │   ├── algorithm.mojopkg
        │   │   ├── autotune.mojopkg
        │   │   ├── base64.mojopkg
        │   │   ├── benchmark.mojopkg
        │   │   ├── builtin.mojopkg
        │   │   ├── complex.mojopkg
        │   │   ├── math.mojopkg
        │   │   ├── memory.mojopkg
        │   │   ├── os.mojopkg
        │   │   ├── python.mojopkg
        │   │   ├── random.mojopkg
        │   │   ├── runtime.mojopkg
        │   │   ├── sys.mojopkg
        │   │   ├── tensor.mojopkg
        │   │   ├── testing.mojopkg
        │   │   ├── time.mojopkg
        │   │   └── utils.mojopkg
        │   └── mojo-repl-entry-point
        ├── licenses
        │   ├── LICENSE
        │   └── Third-Party-Notices
        ├── modular.cfg
        ├── root.json
        ├── scripts
        │   └── post-install
        │       ├── install-dependencies.sh
        │       ├── pick_python.py
        │       ├── requirements.txt
        │       └── self-test.py
        ├── share
        │   └── man
        │       └── man1
        │           ├── mojo.1
        │           ├── mojo-build.1
        │           ├── mojo-demangle.1
        │           ├── mojo-doc.1
        │           ├── mojo-format.1
        │           ├── mojo-package.1
        │           ├── mojo-repl.1
        │           └── mojo-run.1
        ├── snapshot.json
        ├── targets.json
        ├── test
        │   ├── test_format.mojo
        │   ├── test_jupyter.ipynb
        │   ├── test_mandelbrot.mojo
        │   ├── test_package
        │   │   └── __init__.mojo
        │   ├── test_package_user.mojo
        │   └── test_python.mojo
        ├── timestamp.json
        └── VERSION

26 directories, 133 files

References

Modular Developer Console

MOJO 系列第一篇: 在 Ubuntu 环境下安装本地 SDK

Zeyang Lin — Fri, 08 Sep 2023 10:00:00 GMT

那个号称 比 Python 快 35000倍 的 Mojo 语言，今天终于开放了 SDK 的下载。就是说，你可以在自己的本地环境安装 Mojo 并运行 Mojo 程序了。

那么这篇文章是用来记录在 Ubuntu 环境下如何安装 SDK。

首先来看看前置条件－－官方的系统需求

System Requirements

Ubuntu 20.04 and later
x86-64 CPU and minimum 4 GB RAM
Python 3.8 - 3.10
g++ or clang++ compiler

并无苛刻之处，都2023年了这些应该都是基础配置了吧。（除非你不用 Ubuntu 系列的 Linux）

那我自己的环境如下

My environment

Kubuntu 22.04.3
AMD CPU with 16GB RAM
Python 3.10.12
g++ 11.4.0

然后你需要在 Modular 网站（https://developer.modular.com/download）上面用邮箱注册一个帐号，来获得你的 AUTHKEY 。这个 KEY 是后面步骤用来验证你的身份的。图中的 MODULAR_AUTH= 后面的部分就是你的 AUTHKEY。

满足了官方需求后，下面就是一步一步安装了。需要注意的是你似乎是需要魔法才能成功完成下面的步骤。

安装步骤

1. 安装 Modular CLI

Modular CLI 是安装 mojo 的前置条件

# 首先切换到 root 用户：
sudo -u root -i

# 然后执行以下命令：
apt-get install -y apt-transport-https &&
  keyring_location=/usr/share/keyrings/modular-installer-archive-keyring.gpg &&
  curl -1sLf 'https://dl.modular.com/bBNWiLZX5igwHXeu/installer/gpg.0E4925737A3895AD.key' |  gpg --dearmor >> ${keyring_location} &&
  curl -1sLf 'https://dl.modular.com/bBNWiLZX5igwHXeu/installer/config.deb.txt?distro=debian&codename=wheezy' > /etc/apt/sources.list.d/modular-installer.list &&
  apt-get update &&
  apt-get install -y modular

# 然后切换回你自己的普通用户：
exit

2.验证 `modular` 已经安装

在命令行执行：

which modular

如果有下面的输出则表明modular安装成功

/usr/bin/modular

如果没有任何输出，那你可能是需要魔法了。

3.安装 Mojo SDK

modular安装好后，就可以安装mojo了。

在命令行执行：

# 把下面的 <YOUR AUTH KEY> 替换成你自己的 key
modular auth <YOUR AUTH KEY> && modular install mojo

等待时间可能会比较久。。。下面就是输出，可以看到它还会安装很多 python 库到系统的 python 环境里。。。

# Found release for https://packages.modular.com/mojo @ 0.2.1, installing to /home/******/.modular/pkg/packages.modular.com_mojo
# Downloads complete, setting configs...
# Configs complete, running post-install hooks...

< 中间省略掉 >

Successfully installed ansiwrap-0.8.4 attrs-23.1.0 certifi-2023.7.22 charset-normalizer-3.2.0 entrypoints-0.4 fastjsonschema-2.18.0 find_libpython-0.3.0 idna-3.4 jsonschema-4.19.0 jsonschema-specifications-2023.7.1 jupyter-core-5.3.1 jupyter_client-8.3.1 nbclient-0.8.0 nbformat-5.9.2 papermill-2.4.0 platformdirs-3.10.0 python-dateutil-2.8.2 pyzmq-25.1.1 referencing-0.30.2 requests-2.31.0 rpds-py-0.10.2 tenacity-8.2.3 textwrap3-0.9.2 tornado-6.3.3 tqdm-4.66.1 traitlets-5.9.0 urllib3-2.0.4
。。。。。。。
Testing `MODULAR_HOME=/home/******/.modular`
* `/home/******/.modular/pkg/packages.modular.com_mojo/bin/mojo`...
TEST: `mojo --help`... OK
TEST: `mojo run --help`... OK
TEST: `mojo build test_mandelbrot.mojo`... OK
TEST: `mojo build test_python.mojo`... OK
TEST: `mojo demangle`... OK
TEST: `mojo format`... OK
TEST: `mojo package`... OK
TEST: `mojo test_mandelbrot.mojo`... OK
TEST: `mojo test_python.mojo`... OK
TEST: `mojo repl`... OK

🔥 Mojo installed! 🔥

Now run the following commands if you are using bash:

echo 'export MODULAR_HOME="/home/******/.modular"' >> ~/.bashrc
echo 'export PATH="/home/******/.modular/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

If you are using ZSH, run the following commands:

echo 'export MODULAR_HOME="/home/******/.modular"' >> ~/.zshrc
echo 'export PATH="/home/******/.modular/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

Then enter 'mojo' to start the Mojo REPL.

For tool help, enter 'mojo --help'.
For more docs, see https://docs.modular.com/mojo.

4.添加 `mojo` 到 `PATH`

# 把下面两个 <USERNAME> 替换成你自己的用户名
echo 'export MODULAR_HOME="/home/<USERNAME>/.modular"' >> ~/.bashrc

echo 'export PATH="/home/<USERNAME>/.modular/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.bashrc

# 重新加载 .bachrc 令改动生效
source ~/.bashrc

现在验证 mojo 命令是否已经能用了:

which mojo

若输出为下面内容则表示安装成功：

/home/******/.modular/pkg/packages.modular.com_mojo/bin/mojo

5. 体验 Mojo REPL

在命令行执行：

mojo

就进到了 mojo 的互动编程环境。熟悉 Python 或其它类似语言的小伙伴对这个一定不陌生。

Welcome to Mojo! 🔥 Expressions are delimited by a blank line. Type :mojo help for further assistance.

那么至此 mojo 的基础开发环境就已经搭建好了，在下一篇文章中我会记录如何运行最基础的 “Hello world” 程序。

Bonus Round: 看看 mojo 目录的文件夹结构

tree $MODULAR_HOME

/home/******/.modular
├── crashdb
│   ├── attachments
│   ├── completed
│   ├── new
│   ├── pending
│   └── settings.dat
├── modular.cfg
└── pkg
    └── packages.modular.com_mojo
        ├── bin
        │   ├── lldb
        │   ├── lldb-argdumper
        │   ├── lldb-server
        │   ├── lldb-vscode
        │   ├── modular-crashpad-handler
        │   ├── mojo
        │   └── mojo-lsp-server
        ├── installed.json
        ├── jupyter
        │   ├── kernel
        │   │   ├── logo-64x64.png
        │   │   ├── logo.svg
        │   │   └── mojokernel.py
        │   └── manage_kernel.py
        ├── lib
        │   ├── libKGENCompilerRTShared.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libKGENCompilerRTShared.so.18git
        │   ├── libKGENCompilerRTShared.so.18git
        │   ├── libKGENCompilerRT-static.a
        │   ├── libLLCLRuntimeGlobals.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libLLCLRuntimeGlobals.so.18git
        │   ├── libLLCLRuntimeGlobals.so.18git
        │   ├── liblldb.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/liblldb.so.18.0.0git
        │   ├── liblldb.so.18.0.0git
        │   ├── liblldb.so.18git -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/liblldb.so.18.0.0git
        │   ├── libMojoJupyter.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libMojoJupyter.so.18git
        │   ├── libMojoJupyter.so.18git
        │   ├── libMojoLLDB.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libMojoLLDB.so.18git
        │   ├── libMojoLLDB.so.18git
        │   ├── libMSupportGlobals.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libMSupportGlobals.so.18git
        │   ├── libMSupportGlobals.so.18git
        │   ├── liborc_rt.a
        │   ├── lldb-visualizers
        │   │   ├── lldbDataFormatters.py
        │   │   └── mlirDataFormatters.py
        │   ├── mblack
        │   │   ├── base_library.zip
        │   │   ├── importlib_metadata-6.8.0.dist-info
        │   │   │   ├── INSTALLER
        │   │   │   ├── LICENSE
        │   │   │   ├── METADATA
        │   │   │   ├── RECORD
        │   │   │   ├── top_level.txt
        │   │   │   └── WHEEL
        │   │   ├── libbz2.so.1.0
        │   │   ├── libcrypto.so.1.1
        │   │   ├── lib-dynload
        │   │   │   ├── _asyncio.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _bz2.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_cn.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_hk.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_iso2022.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_jp.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_kr.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_tw.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _contextvars.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _ctypes.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _decimal.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _hashlib.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _json.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _lzma.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── mmap.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _multibytecodec.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _multiprocessing.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _opcode.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _posixshmem.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _queue.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── resource.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _ssl.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── termios.cpython-38-x86_64-linux-gnu.so
        │   │   │   └── _uuid.cpython-38-x86_64-linux-gnu.so
        │   │   ├── libexpat.so.1
        │   │   ├── libffi.so.7
        │   │   ├── liblzma.so.5
        │   │   ├── libmpdec.so.2
        │   │   ├── libpython3.8.so.1.0
        │   │   ├── libssl.so.1.1
        │   │   ├── libuuid.so.1
        │   │   ├── libz.so.1
        │   │   ├── mblack
        │   │   └── mblib2to3
        │   │       ├── Grammar.txt
        │   │       ├── __init__.py
        │   │       ├── LICENSE
        │   │       ├── PatternGrammar.txt
        │   │       ├── pgen2
        │   │       │   ├── conv.py
        │   │       │   ├── driver.py
        │   │       │   ├── grammar.py
        │   │       │   ├── __init__.py
        │   │       │   ├── literals.py
        │   │       │   ├── parse.py
        │   │       │   ├── pgen.py
        │   │       │   ├── tokenize.py
        │   │       │   └── token.py
        │   │       ├── pygram.py
        │   │       ├── pytree.py
        │   │       └── README
        │   ├── mojo
        │   │   ├── algorithm.mojopkg
        │   │   ├── autotune.mojopkg
        │   │   ├── base64.mojopkg
        │   │   ├── benchmark.mojopkg
        │   │   ├── builtin.mojopkg
        │   │   ├── complex.mojopkg
        │   │   ├── math.mojopkg
        │   │   ├── memory.mojopkg
        │   │   ├── os.mojopkg
        │   │   ├── python.mojopkg
        │   │   ├── random.mojopkg
        │   │   ├── runtime.mojopkg
        │   │   ├── sys.mojopkg
        │   │   ├── tensor.mojopkg
        │   │   ├── testing.mojopkg
        │   │   ├── time.mojopkg
        │   │   └── utils.mojopkg
        │   └── mojo-repl-entry-point
        ├── licenses
        │   ├── LICENSE
        │   └── Third-Party-Notices
        ├── modular.cfg
        ├── root.json
        ├── scripts
        │   └── post-install
        │       ├── install-dependencies.sh
        │       ├── pick_python.py
        │       ├── requirements.txt
        │       └── self-test.py
        ├── share
        │   └── man
        │       └── man1
        │           ├── mojo.1
        │           ├── mojo-build.1
        │           ├── mojo-demangle.1
        │           ├── mojo-doc.1
        │           ├── mojo-format.1
        │           ├── mojo-package.1
        │           ├── mojo-repl.1
        │           └── mojo-run.1
        ├── snapshot.json
        ├── targets.json
        ├── test
        │   ├── test_format.mojo
        │   ├── test_jupyter.ipynb
        │   ├── test_mandelbrot.mojo
        │   ├── test_package
        │   │   └── __init__.mojo
        │   ├── test_package_user.mojo
        │   └── test_python.mojo
        ├── timestamp.json
        └── VERSION

26 directories, 133 files

本文参考了

Modular Developer Console

[one-liner] Install Julia (juliaup)

Zeyang Lin — Tue, 16 May 2023 14:36:16 GMT

One-Liner series: juliaup

source: julialang.org

Install on Ubuntu

curl -fsSL https://install.julialang.org | sh

Update on Ubuntu (via ‘release’ channel)

juliaup update release

[one-liner] Install Rust (Rustup)

Zeyang Lin — Tue, 16 May 2023 14:24:06 GMT

One-Liner series: Rustup

source: rust-lang.org

Install on Ubuntu

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Update on Ubuntu

rustup update

Github 连接问题之 REMOTE HOST IDENTIFICATION HAS CHANGED!

Zeyang Lin — Fri, 24 Mar 2023 13:42:41 GMT

缘起

今天在 git bash 命令行往 github push 代码的时候突然收到大大的警告信息，如下：

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY! Someone could be eavesdropping on you right now (man-in-the-middle attack)! It is also possible that a host key has just been changed. The fingerprint for the RSA key sent by the remote host is SHA256:uNiVztksCsDhcc0u9e8BujQXVUpKZIDTMczCvj3tD2s. Please contact your system administrator. Add correct host key in **************************** to get rid of this message. Offending RSA key in ****************************:2 Host key for github.com has changed and you have requested strict checking. Host key verification failed. fatal: Could not read from remote repository. Please make sure you have the correct access rights and the repository exists.

这个仓库是用 ssh 连接作为 remote 的。

问题在哪

遂 google 之，发现就在今天 github 的 blog 发了 We updated our RSA SSH host key。

原来github在今天下午1点左右把他们的 RSA SSH 主机 key 给换了。

出现上面那个错误说明我在我的 ~/.ssh/known_hosts 里有过期的那个 key 的公钥。

解决方法

blog中给出的解决方法很简单，把 known_hosts 里的过期 key 删掉就行了：

$ ssh-keygen -R github.com

#Host github.com found: line 2
********/.ssh/known_hosts updated.
Original contents retained as **********/.ssh/known_hosts.old

然后进行任意一项连接到 remote 的操作，比如 git fetch，就会提示把新的公钥添加到我的 known_hosts 里，当然选 yes：

The authenticity of host ‘github.com (140.82.121.4)’ can’t be established. ED25519 key fingerprint is SHA256:+DiY3wvvV6TuJJhbpZisF/zLDA0zPMSvHdkr4UvCOqU. This key is not known by any other names. Are you sure you want to continue connecting (yes/no/[fingerprint])? yes Warning: Permanently added ‘github.com’ (ED25519) to the list of known hosts.

问题解决。

后记

最新的公钥在 github docs 里就可以找到 GitHub’s SSH key fingerprints 。

github.com ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOMqqnkVzrm0SdG6UOoqKLsabgH5C9okWi0dh2l9GKJl
github.com ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBEmKSENjQEezOmxkZMy7opKgwFB9nkt5YRrYMjNuG5N87uRgg6CLrbo5wAdT/y6v0mKV0U2w0WZ2YB/++Tpockg=
github.com ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCj7ndNxQowgcQnjshcLrqPEiiphnt+VTTvDP6mHBL9j1aNUkY4Ue1gvwnGLVlOhGeYrnZaMgRK6+PKCUXaDbC7qtbW8gIkhL7aGCsOr/C56SJMy/BCZfxd1nWzAOxSDPgVsmerOBYfNqltV9/hWCqBywINIR+5dIg6JTJ72pcEpEjcYgXkE2YEFXV1JHnsKgbLWNlhScqb2UmyRkQyytRLtL+38TGxkxCflmO+5Z8CSSNY7GidjMIZ7Q4zMjA2n1nGrlTDkzwDCsw+wqFPGQA179cnfGWOWRVruj16z6XyvxvjJwbz0wQZ75XK5tKSb7FNyeIEs4TT4jk+S4dhPeAUC5y+bDYirYgM4GC7uEnztnZyaVWQ7B381AK4Qdrwt51ZqExKbQpTUNn+EjqoTwvqNj4kqx5QUCI0ThS/YkOxJCXmPUWZbhjpCg56i+2aB6CmK2JGhn57K5mj0MNdBXA4/WnwH6XoPWJzK5Nyu2zB3nAZp+S5hpQs+p1vN1/wsjk=

— 全文完 —

[one-liner] Install Node.js and NPM

Zeyang Lin — Sat, 07 May 2022 14:06:58 GMT

One-Liner series: Node.js and NPM

Option 1: DEB package through apt

source: nodesource github

Install on Ubuntu

curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
sudo apt install -y nodejs

Install on Debian, as root

curl -fsSL https://deb.nodesource.com/setup_24.x | bash -
apt install -y nodejs

Option 2: Through NVM (Node Version Manager)

source: nodejs.org

# Install NVM
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

# Download and install Node.js
nvm install 24

[one-liner] Install minikube, kubectl and kustomize

Zeyang Lin — Wed, 23 Jun 2021 09:33:22 GMT

One-liner series: minikube, kubectl and kustomize

OS	Shell
Ubuntu 20.04 amd64	Bash

Install minikube

source

As Binary

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64

sudo install minikube-linux-amd64 /usr/local/bin/minikube && rm minikube-linux-amd64

As DEB

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.deb

sudo dpkg -i minikube_latest_amd64.deb

Install kubectl

source

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

To download a specific version, replace the $(curl -L -s https://dl.k8s.io/release/stable.txt) portion of the command with the specific version. eg. v1.30.0: curl -LO https://dl.k8s.io/release/v1.30.0/bin/linux/amd64/kubectl

Install kustomize

source

curl -s "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh"  | bash

sudo install -o root -g root -m 0755 kustomize /usr/local/bin/kustomize

Setup command-line completion for minikube

source

sudo su root && minikube completion bash > /etc/bash_completion.d/minikube

Setup command-line completion for kubectl

source

sudo kubectl completion bash > /etc/bash_completion.d/kubectl

Setup command-line completion for kustomize

sudo kustomize completion bash > /etc/bash_completion.d/kustomize

[one-liner] Install Docker Engine community and docker-compose

Zeyang Lin — Wed, 23 Jun 2021 08:11:39 GMT

One-Liner series: Docker and docker-compose

OS	Shell
Ubuntu Server 22.04 Jammy	Bash

Install Docker Engine community

source

curl -fsSL https://get.docker.com -o get-docker.sh && sudo sh ./get-docker.sh

docker-compose is now installed along with docker engine, and becomes docker compose. However docker-compose can still be installed as a stand-alone binary:

sudo curl -SL https://github.com/docker/compose/releases/download/v2.27.0/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose

My Visual Studio Code extensions for python & other development

Zeyang Lin — Mon, 31 May 2021 01:47:01 GMT

Python

ms-python.python

Pylance

ms-python.vscode-pylance

Black Formatter

ms-python.black-formatter

Flake8

ms-python.flake8

isort

ms-python.isort

Jupyter

ms-toolsai.jupyter

Data Wrangler

ms-toolsai.datawrangler

Mypy Type Checker

ms-python.mypy-type-checker

Pylint

ms-python.pylint

Ruff

charliermarsh.ruff

ty

astral-sh.ty

autoDocstring: VSCode Python Docstring Generator

njpwerner.autodocstring

Python Indent

kevinrose.vsc-python-indent

Sublime Text Keymap and Settings Importer

ms-vscode.sublime-keybindings note that it automatically imports sublime key bindings after installation, although it also prompts you to explicitly import a sublime settings file (while could be ignored).

Docker

ms-azuretools.vscode-docker

Kubernetes

ms-kubernetes-tools.vscode-kubernetes-tools

Remote - SSH

ms-vscode-remote.remote-ssh

Remote - Containers

ms-vscode-remote.remote-containers

GitLens

eamodio.gitlens

vscode-json

andyyaldoo.vscode-json

YAML

redhat.vscode-yaml

Even Better TOML

tamasfe.even-better-toml

Rainbow CSV

mechatroner.rainbow-csv

Prettier - Code formatter

esbenp.prettier-vscode

Prettier SQL VSCode

inferrinizzard.prettier-sql-vscode

SQL Formatter

adpyke.vscode-sql-formatter

Mojo

modular-mojotools.vscode-mojo

Amazon Q

amazonwebservices.amazon-q-vscode

Baidu Comate

baiducomate.comate

Cline

saoudrizwan.claude-dev

CodeGeeX

aminer.codegeex

Windsurf Plugin (formerly Codeium)

codeium.codeium

Gemini Code Assist

google.geminicodeassist

Google Cloud Code

googlecloudtools.cloudcode

Github Copilot

github.copilot

Github Copilot Chat

github.copilot-chat

iFlyCode

anhuizhuojiantechnology.iflycode

TONGYI Lingma

alibaba-cloud.tongyi-lingma

Trae AI(formerly MarsCode): Coding Assistant

marscode.marscode-extension

GitHub Theme

github.github-vscode-theme

BlueberryPy

This Month for Pythonistas - September 2026

Events & Social

New Versions

Tutorials

deeplearning.ai’s Building Adaptive AI Agents by Oracle

deeplearning.ai’s Building AI Assistants with On-Device Memory by Qdrant

RealPython’s How to Write an AGENTS.md File for a Python Project

RealPython’s How to Review AI-Generated Python Code Efficiently

Articles

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

Repositories

BruceEckel/ThinkingInPython (CC BY-NC-ND 4.0)

reflex-dev/xy (Apache 2.0)

gi0baro/tonio (BSD-3-Clause)

Have time for some fun?

[PyCon China 2026] It's Time to Learn (Some) Rust — Starting from a Faster pip install

It’s Time to Learn (Some) Rust — Starting from a Faster pip install

This Month for Pythonistas - August 2026

Events & Social

New Versions

Tutorials

deeplearning.ai’s AI Coding Workflows: From Cloud to Local by Paul Everitt

RealPython’s How to Integrate OpenTelemetry With a FastAPI App

Articles

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

Repositories

RyanCodrai/turbovec (MIT)

Have time for some fun?

Gamescom 2026

This Month for Pythonistas - July 2026

Events & Social

EuroPython 2026

New Versions

Tutorials

Deeplearning.ai’s AI Code Reviews

RealPython’s LangGraph Tutorial: Build Stateful AI Agents in Python

RealPython’s CrewAI in Python: Coordinating Teams of AI Agents

Articles

Podcasts

🥝 core.py

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

🚀 VS Code Insiders Podcast

Repositories

This Month for Pythonistas - June 2026

Events & Social

EuroPython 2026 schedule is revealed 📣

New Versions

Tutorials

DeepLearning.ai’s Fast & Efficient LLM Inference with vLLM from Red Hat

DeepLearning.ai’s Voice for AI Agents and Applications from Vocal Bridge

Microsoft’s Rust for Python Programmers

Articles