playbooks

home / skills / nevaberry / nevaberry-plugins / python-knowledge-patch

python-knowledge-patch skill

/plugins/python-knowledge-patch/skills/python-knowledge-patch

This skill helps you write Python code with 3.13+ features like t-strings, deferred annotations, and free-threaded execution, boosting modern syntax adoption.

npx playbooks add skill nevaberry/nevaberry-plugins --skill python-knowledge-patch

Review the files below or copy the command above to add this skill to your agents.

Files (5)
SKILL.md
4.7 KB
---
name: python-knowledge-patch
description: This skill should be used when writing Python code, using t-strings (template strings), deferred annotation evaluation, free-threaded Python, subinterpreters, zstd compression, or any Python features from 3.13+ (2024-2026).
license: MIT
metadata:
  author: Nevaberry
  version: "3.14"
---

# Python 3.13+ Knowledge Patch

Claude's baseline knowledge covers Python through 3.12. This skill provides features from 3.13 (Oct 2024) onwards.

**Source**: Python "What's New" documentation at https://docs.python.org/3/whatsnew/

## 3.13 Breaking Changes

| Change | Impact |
|--------|--------|
| 19 "dead battery" modules removed (PEP 594) | `ImportError` for `cgi`, `crypt`, `imghdr`, `telnetlib`, etc. See [removals](references/removals.md) |
| `locals()` returns snapshots in functions (PEP 667) | `exec()`/`eval()` in functions need explicit namespace. See [new-modules](references/new-modules.md) |
| `TypedDict("T", x=int)` keyword syntax removed | Use class syntax or `TypedDict("T", {"x": int})` |
| `pathlib.Path.glob("**")` returns files AND dirs | Add trailing `/` for dirs only: `glob("**/")` |
| Docstring leading whitespace stripped | May affect `doctest` tests |

## 3.13 New Features

| Feature | Quick reference |
|---------|----------------|
| Free-threaded CPython (PEP 703) | `python3.13t`, `sys._is_gil_enabled()`, `PYTHON_GIL=0`. See [concurrency](references/concurrency.md) |
| `copy.replace()` protocol | `copy.replace(obj, field=val)`, implement `__replace__()`. See [new-modules](references/new-modules.md) |
| `warnings.deprecated()` (PEP 702) | `@deprecated("msg")` — runtime warning + type checker signal. See [new-modules](references/new-modules.md) |

## 3.14 New Syntax

| Feature | Quick reference |
|---------|----------------|
| T-strings (PEP 750) | `t"Hello {name}"` → `Template` object. `from string.templatelib import Template, Interpolation`. See [new-syntax](references/new-syntax.md) |
| Deferred annotations (PEP 649/749) | Forward refs no longer need quotes. `from annotationlib import get_annotations, Format`. See [new-syntax](references/new-syntax.md) |
| `except` without brackets (PEP 758) | `except A, B:` (no parens, no `as`). Parens still needed with `as`. |

## 3.14 New Modules

| Module | Quick reference |
|--------|----------------|
| `compression.zstd` (PEP 784) | `from compression import zstd; zstd.compress(data)`. See [new-modules](references/new-modules.md) |
| `concurrent.interpreters` (PEP 734) | Subinterpreters + `InterpreterPoolExecutor`. See [concurrency](references/concurrency.md) |
| `annotationlib` | `get_annotations(obj, format=Format.FORWARDREF)` |
| `functools.Placeholder` | `partial(func, Placeholder, fixed_arg)` — reserve positional slots |

## 3.14 Breaking Changes

| Change | Impact |
|--------|--------|
| `asyncio.get_event_loop()` raises `RuntimeError` | Must use `asyncio.run()` or `asyncio.Runner` |
| `multiprocessing` default → `'forkserver'` on Linux | May cause pickling errors; use `get_context('fork')` |
| `int()` no longer uses `__trunc__()` | Must implement `__int__()` or `__index__()` |
| `functools.partial` is method descriptor | Wrap in `staticmethod()` for classes |
| `from __future__ import annotations` deprecated | Unchanged behavior; removal after 2029 |
| `ast.Num`/`Str`/`Bytes` removed | Use `ast.Constant` |
| `asyncio` child watcher classes removed | Use `asyncio.run()` |
| SyntaxWarning in `finally` (PEP 765) | `return`/`break`/`continue` in `finally` now warns |

## 3.14 New APIs

| API | Quick reference |
|-----|----------------|
| `sys.remote_exec(pid, script)` (PEP 768) | Attach debugger to running process; `python -m pdb -p PID`. See [new-modules](references/new-modules.md) |
| `io.Reader` / `io.Writer` | Simpler protocol alternatives to `typing.IO` |
| `uuid.uuid7()` | Time-ordered UUID (RFC 9562); also `uuid6()`, `uuid8()` |
| `heapq.*_max()` | `heapify_max()`, `heappush_max()`, `heappop_max()`, etc. |
| Free-threading (PEP 779) | Now officially supported; 5-10% overhead |

## Reference Files

For detailed patterns, code examples, and migration guidance, consult:

- **[`references/new-syntax.md`](references/new-syntax.md)** — T-strings (template processors, API), deferred annotations (`annotationlib`), `except` without brackets
- **[`references/new-modules.md`](references/new-modules.md)** — `compression.zstd`, `functools.Placeholder`, `copy.replace()`, `warnings.deprecated()`, `locals()` semantics, remote debugging, `io.Reader`/`Writer`, `uuid.uuid7()`, `heapq` max-heap
- **[`references/concurrency.md`](references/concurrency.md)** — Free-threaded CPython (GIL-free mode), subinterpreters, `InterpreterPoolExecutor`
- **[`references/removals.md`](references/removals.md)** — Dead batteries (19 modules), 3.13/3.14 removals, breaking behavior changes

Overview

This skill provides up-to-date guidance and patterns for Python features added or changed in Python 3.13 and later (2024+). It fills gaps around new syntax, modules, concurrency models, and breaking changes so you can write correct, forward-compatible Python code. Use it when you need concrete examples, migration notes, or API references for post-3.12 language and library changes.

How this skill works

The skill inspects code patterns and recommends updated syntax, APIs, and migration steps for features like t-strings, deferred annotations, free-threaded CPython, subinterpreters, zstd compression, and other 3.13+ additions. It highlights breaking changes, suggests replacements or workarounds, and supplies concise examples and best-practice rules to avoid common pitfalls. It also maps old idioms to new library calls and semantics introduced after the model cutoff.

When to use it

  • Upgrading a codebase to Python 3.13 or newer and needing migration guidance
  • Writing code that uses new syntax (t-strings, deferred annotations, except without brackets)
  • Implementing concurrency with free-threaded CPython or subinterpreters
  • Adding or migrating to new modules like compression.zstd, annotationlib, or concurrent.interpreters
  • Handling breaking changes such as removed modules or changed locals()/exec() semantics

Best practices

  • Check for removed "dead battery" modules and replace usage with maintained libraries or modern stdlib alternatives
  • Use explicit namespaces when using exec()/eval() inside functions because locals() now returns snapshots
  • Prefer the new standard modules (compression.zstd, annotationlib, concurrent.interpreters) over custom hacks for the same functionality
  • When using free-threaded CPython, test for subtle concurrency races and measure the modest overhead (5–10%)
  • Adopt new APIs (copy.replace, warnings.deprecated) to express intent and improve tooling support
  • Run full test suites under the target Python minor version to catch SyntaxWarnings and behavior changes (doctests, asyncio, multiprocessing)

Example use cases

  • Convert a string-formatting utility to use t-strings (PEP 750) and Template APIs for safer interpolation
  • Update code that relied on implicit forward-reference strings to use deferred annotation helpers from annotationlib
  • Migrate an app to use compression.zstd for faster compression with minimal API changes
  • Rewrite worker pools to use concurrent.interpreters and InterpreterPoolExecutor for subinterpreter-based isolation
  • Replace removed stdlib modules with third-party equivalents and add compatibility checks during import

FAQ

Will code using exec()/eval() inside functions behave differently?

Yes. locals() returns snapshots in functions, so exec()/eval() must be given explicit namespaces to modify or access local state reliably.

Should I expect performance changes with free-threaded CPython?

Free-threading reduces GIL contention but can add a 5–10% overhead in some workloads; benchmark critical paths and test for concurrency correctness.