Llm on BlueberryPy

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.

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 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.

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

Llm on BlueberryPy

This Month for Pythonistas - April 2026

Events & Social

DjangoCon Europe 2026

New Versions

Tutorials

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

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

DeepLearning.ai’s Building Multimodal Data Pipelines from Snowflake

RealPython’s Variables in Python: Usage and Best Practices

Articles

Podcasts

🥝 core.py

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🚀 VS Code Insiders Podcast

Repositories

NousResearch/hermes-agent (MIT)

dropseed/plain (BSD-3)

smelloscope/smello (MIT)

This Month for Pythonistas - March 2026

Events & Social

New Versions

Python 3.15.0 alpha 7

Tutorials

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

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

Articles

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

Repositories

This Month for Pythonistas - February 2026

Events & Social

New Versions

Python 3.15.0 alpha 6

transformers 5

isort 8

Tutorials

Deeplearning.ai’s Agent Skills with Anthropic by Anthropic

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

Articles

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

VS Code Insiders Podcast

Repositories

volcengine/OpenViking (Apache 2.0)

NevaMind-AI/memU (Apache 2.0)

Have time for some fun?

Kena: Scars of Kosmora is announced during State of Play

This Month for Pythonistas - January 2026

Events & Social

EuroPython 2026 Location Revealed

New Versions

Python 3.15.0 alpha 5

Pandas 3.0.0

FastMCP 3.0.0 beta 1

Tutorials