**2.0.0** (March 2026, in progress) — *"Six impossible things before breakfast"* edition:

**IMPORTANT**:

- **Python version support**: 3.10–3.14 (dropped 3.8, 3.9; added 3.13, 3.14). PyPy 3.11.

- If you need `unpythonic` for Python 3.8 or 3.9, use version 1.0.0.

- **Requires mcpyrate >= 4.0.0**.

- mcpyrate 4.0.0 dropped the `Str`, `Num`, `NameConstant` AST compatibility shims and the `getconstant` helper.

**New**:

- **Python 3.13 and 3.14 support**.

- `autoreturn` macro now handles `match`/`case` statements. Each case branch has its own tail position.

- New scope analyzer tests for `match`/`case` patterns and `try`/`except*`.

- Test runner (`runtests.py`) now supports version-suffixed test modules (e.g. `test_foo_3_11.py` runs only on Python 3.11+).

- Runtime type checker (`unpythonic.typecheck`): fixed compatibility with Python 3.14, where `typing.Union` is no longer a `_GenericAlias`. Now uses `typing.get_origin` (available since 3.8) instead of a local copy.

- Runtime type checker: fixed `TypeVar` detection to use `isinstance(T, typing.TypeVar)` instead of a fragile `repr`-based heuristic.

- Runtime type checker: `typing.Reversible` check now uses `isinstance` instead of a `hasattr("__reversed__")` workaround from the Python 3.5 era.

- Runtime type checker: removed redundant `safeissubclass` fallbacks for generic types — `typing.get_origin` handles both bare and parameterized generics on 3.10+.

- Scope analyzer: fixed `MatchCapturesCollector` bug where class references (e.g. `Point` in `case Point(x, y):`) were incorrectly collected as captured variable names. Match captures are `MatchAs`/`MatchStar` nodes with bare strings, not `Name` nodes.

- Macro layer: updated all `hasattr(tree, "ctx")` checks to use `getattr` with defaults, for correct behavior on Python 3.13+ where AST fields always exist with default values.

- Macro layer: updated `arguments()` constructor calls to always include `posonlyargs=[]`, avoiding a `DeprecationWarning` on Python 3.13 (will become an error in 3.15).

**Deprecated**:

- Parenthesis syntax for macro arguments (e.g. `let((x, 1), (y, 2))`). Use bracket syntax instead: `let[[x, 1], [y, 2]]`. The parenthesis syntax is kept for backward compatibility but may be removed in a future version.

- **D1**: Document pyc cache pitfall and test result reading for other projects using mcpyrate/unpythonic.test.fixtures. The CLAUDE.md additions from the 2.0.0 modernization (never `py_compile` macro-enabled code; how to read test framework output with Pass/Fail/Error) are useful guidance for any project using these tools. Consider adding similar notes to mcpyrate's docs and/or unpythonic's user-facing documentation. (Discovered during Phase 3.)

- **D4**: `typecheck.py` — expand runtime type checker to support more `typing` features: NamedTuple, DefaultDict, Counter, ChainMap, OrderedDict, IO/TextIO/BinaryIO, Pattern/Match, Generic, Type, Awaitable, Coroutine, AsyncIterable, AsyncIterator, ContextManager, AsyncContextManager, Generator, AsyncGenerator, NoReturn, ClassVar, Final, Protocol, TypedDict, Literal, ForwardRef. Would improve `unpythonic.dispatch` (multiple dispatch). (Discovered during Phase 4 cleanup.)

- **D5**: `runtests.py` — version-suffix skip should signal `TestWarning` (via `unpythonic.conditions.signal`) instead of printing and continuing. This would make skips visible in the testset warning count, consistent with how optional dependency failures show as errors. Currently the skip message bypasses the testset reporting mechanism. (Discovered during Phase 5.)

from unpythonic.test.fixtures import (session, testset, maybe_colorize,

tests_errored, tests_failed, TestConfig)

from mcpyrate.colorizer import Style

def _version_suffix(modulename):

"""Parse version suffix from module name.

# Match the final component of a dotted module name.

m = re.search(r"_(\d+)_(\d+)$", modulename)

if m:

return (int(m.group(1)), int(m.group(2)))

return None

ver = _version_suffix(m)

if ver is not None and sys.version_info < ver:

msg = (f"Skipping '{m}' (requires Python {ver[0]}.{ver[1]}+, "

f"running {sys.version_info.major}.{sys.version_info.minor})")

TestConfig.printer(maybe_colorize(msg, Style.DIM,

TestConfig.ColorScheme.HEADING))

continue

from mcpyrate.astcompat import TryStar, MatchStar, MatchMapping, MatchAs

# Python 3.10+: `match`/`case` captures are `MatchAs(name='x')` and

# `MatchStar(name='rest')` with bare strings (not `Name` nodes). The `name`

# is `None` for `_` (wildcard, doesn't capture). `Name` nodes in patterns are

# class references (e.g. `Point` in `case Point(x, y):`), not captures.

#

# `generic_visit` handles most match patterns automatically, since `MatchAs`

# and `MatchStar` nodes appear as children. The one exception is

# `MatchMapping.rest`, which is a bare string attribute (not an AST child).

elif type(tree) in (MatchAs, MatchStar):

if tree.rest is not None: # `**rest` capture

With, AsyncWith, If, IfExp, Try, Match, Assign, Return, Expr,

elif type(tree) is Match: # Python 3.10+: `match`/`case`

for case in tree.cases:

if case.body:

case.body[-1] = self.visit(case.body[-1])

with testset("match/case"): # Python 3.10+

with autoreturn:

def classify(x):

match x:

case 1:

"one"

case 2:

"two"

case _:

"other"

test[classify(1) == "one"]

test[classify(2) == "two"]

test[classify(42) == "other"]

def classify_nested(x):

match x:

case (a, b):

a + b

case [a, b, *rest]:

a + b + sum(rest)

case _:

0

test[classify_nested((3, 4)) == 7]

test[classify_nested([1, 2, 3, 4]) == 10]

test[classify_nested("nope") == 0]

def classify_with_guard(x):

match x:

case n if n < 0:

"negative"

case 0:

"zero"

case n if n > 0:

"positive"

test[classify_with_guard(-5) == "negative"]

test[classify_with_guard(0) == "zero"]

test[classify_with_guard(7) == "positive"]

# Python 3.10+: `match`/`case`

with testset("match/case: get_names_in_store_context"):

# Simple capture

with q as matchcase_simple:

match x: # noqa: F821, it's only quoted.

case y: # noqa: F841, it's only quoted.

pass

test[get_names_in_store_context(matchcase_simple) == ["y"]]

# Wildcard `_` — does NOT capture

with q as matchcase_wildcard:

match x: # noqa: F821, it's only quoted.

case _:

pass

test[get_names_in_store_context(matchcase_wildcard) == []]

# Sequence pattern with star capture

with q as matchcase_sequence:

match x: # noqa: F821, it's only quoted.

case [a, b, *rest]: # noqa: F841, it's only quoted.

pass

test[get_names_in_store_context(matchcase_sequence) == ["a", "b", "rest"]]

# Class pattern — captures `x` and `y`, but NOT the class reference `Point`

with q as matchcase_class:

match x: # noqa: F821, it's only quoted.

case Point(x, y): # noqa: F821, F841, it's only quoted.

pass

names = get_names_in_store_context(matchcase_class)

test["x" in names]

test["y" in names]

test["Point" not in names] # class reference, not a capture

# Class pattern with keyword captures

with q as matchcase_class_kw:

match x: # noqa: F821, it's only quoted.

case Point(x=px, y=py): # noqa: F821, F841, it's only quoted.

pass

names = get_names_in_store_context(matchcase_class_kw)

test["px" in names]

test["py" in names]

test["Point" not in names]

# Mapping pattern with `**rest`

with q as matchcase_mapping:

match x: # noqa: F821, it's only quoted.

case {"key": value, **rest}: # noqa: F841, it's only quoted.

pass

names = get_names_in_store_context(matchcase_mapping)

test["value" in names]

test["rest" in names]

# Nested: mapping containing a class pattern

with q as matchcase_nested:

match x: # noqa: F821, it's only quoted.

case {"key": Point(px, py)}: # noqa: F821, F841, it's only quoted.

pass

names = get_names_in_store_context(matchcase_nested)

test["px" in names]

test["py" in names]

test["Point" not in names] # class reference, not a capture

# OR pattern

with q as matchcase_or:

match x: # noqa: F821, it's only quoted.

case 1 | 2 | 3:

pass

test[get_names_in_store_context(matchcase_or) == []]

# `as` pattern with guard

with q as matchcase_as:

match x: # noqa: F821, it's only quoted.

case (1 | 2) as num: # noqa: F841, it's only quoted.

pass

test[get_names_in_store_context(matchcase_as) == ["num"]]

from ...syntax import macros, test, test_raises, the # noqa: F401

from ...test.fixtures import session, testset

from mcpyrate.quotes import macros, q # noqa: F401, F811

from ...syntax.scopeanalyzer import get_names_in_store_context

def runtests():

with testset("try/except*: get_names_in_store_context"):

# except* binds names just like except

with q as exceptstar_simple:

try:

pass

except* ValueError as eg: # noqa: F841, it's only quoted.

pass

test[get_names_in_store_context(exceptstar_simple) == ["eg"]]

with q as exceptstar_multi:

try:

pass

except* ValueError as eg1: # noqa: F841, it's only quoted.

pass

except* TypeError as eg2: # noqa: F841, it's only quoted.

pass

test[get_names_in_store_context(exceptstar_multi) == ["eg1", "eg2"]]

# Names bound inside the try body are also collected

with q as exceptstar_with_assign:

try:

x = 42 # noqa: F841, it's only quoted.

except* ValueError as eg: # noqa: F841, it's only quoted.

y = 1 # noqa: F841, it's only quoted.

names = get_names_in_store_context(exceptstar_with_assign)

test["x" in the[names]]

test["y" in the[names]]

test["eg" in the[names]]

if __name__ == '__main__': # pragma: no cover

with session(__file__):

runtests()