Use a typeddict as the `case` guard to match structure

Python Help
1

I would like to use typeddicts as the case guards in a match statement:

from typing import TypedDict

class A(TypedDict):
    x: int


class B(TypedDict):
    y: int


def func(value):
    match value:
        case A:
            print("it's an A")
        case B:
            print("it's a B")
        case _:
            print("it's neither")


func({"y": 1})   # should print 'it's a B"

# instead I get this error:
# SyntaxError: name capture 'A' makes remaining patterns unreachable

Why is this not possible? Should it not be a natural extension of structural pattern matching?

1 Like
2

A couple of reasons. This on the surface makes sense, but is actually trying to use two complicated special cases together, like a zip tie and a rivet, instead of using ordinary nuts and bolts. Firstly TypedDict doesn’t even support isinstance checks at run time:

from typing import TypedDict

class A(TypedDict):
    x: int

isinstance({'x' : 1}, A)

    raise TypeError('TypedDict does not support instance and class checks')
TypeError: TypedDict does not support instance and class checks

Secondly the reason you’re getting a Syntax error (and why I personally avoid using match statements in Python), is the patterns after the case statement in the Python language spec, are not any arbitrary Python expression. They must be specific “patterns”. In particular, they must fall under one of the specific categories of pattern in the docs:

3 Likes
3

I think the better way to expect it to work would be case A(): rather than case A:
since case A: looks like a capture pattern than should bind something to the name A

But yes, it seems like this should work - especially since typing.get_type_hints(A) basically gives what’s needed for the mapping pattern.

4

A in the case clause is not a name bound to a particular type; it’s just a capture pattern used to assign the value of value to the name A. If you want to match against a type, you need to use a class pattern.

match value:
    case A():
        ...

This still produces an error, but it gets to the heart of your request:

TypeError: TypedDict does not support instance and class checks

TypedDicts are essential static-only constructs; they do not support runtime checks for conformance to the protocol they define.

(Which leads to a related question: is there a reason that runtime_checkable is only for Protocol, and not TypedDict?)

(And apologies, I’m responding more as if this were a help request than as a proposal to add the support.)

1 Like
5

match-case is not a simple switch statement, but rather an implementation of pattern matching.
As such, it’s necessary to characterize what the destructuring pattern match does.

Although we can do this for literal values, it’s not doable for types. Types can be complex values (e.g. a union of protocols) which are not guaranteed to be runtime checkable.
There have been several requests for more runtime support for type annotations, and this might count as another. But we have to make sure to begin from the common starting point that types are not necessarily understood at runtime today, and that drives a lot of relevant behaviors.

Also, as has been noted above, case binds names, so you need to use an appropriate non-name expression for the pattern.

6

It seems like we could change this:

class_pattern A():
  do what we currently do with normal classes

to this:

class_pattern A():
  if A is a TypedDict:
    call typing.get_type_hints(A) and use the result for mapping_pattern
  else:
    do what we currently do with normal classes
7

This creates a different TypedDict with the same metaclass that passes run-time isinstance checks, and even seems to work with match (after fixing the Syntax error from the original example’s match statement, to create Class matches):

from collections.abc import Mapping
from typing import TypedDict, _TypedDictMeta


def _user_attr_vals(inst):
    built_in_attrs = set(dir(dict))
    return {attr : getattr(inst, attr)
            for attr in dir(inst) 
            if attr not in built_in_attrs
           }


class _RuntimeCheckableTypedDictMeta(type):
    """ Takes a wrecking ball to:
        https://github.com/python/cpython/blob/af00c586525f6018c7ecd877cddeb936f9b2aedf/Lib/typing.py#L3136
    """
    __new__ = TypedDict.__new__
    __call__ = dict


    def __instancecheck__(cls, inst):
        if not isinstance(inst, Mapping):
            # f"{inst} is not a mapping"
            return False
            
        annotations = cls.__annotations__
        
        if not set(inst) == set(annotations):
            #(f"{inst} has missing or extra keys not in: {cls}"
            # f", keys: {set(inst)}, {set(annotations)=}")
            return False
        
        for k, v in inst.items():
            if not isinstance(v, annotations[k]):
                # f'Instance var: {v} is not a {annotations[k]=}')
                return False
               
        return True
        
class RuntimeCheckableTypedDict(metaclass=_RuntimeCheckableTypedDictMeta):
    pass
        
class A(RuntimeCheckableTypedDict):
    x: int

class B(RuntimeCheckableTypedDict):
    y: int
    
    
assert isinstance({'x' : 1}, A)
assert not isinstance({'x': 1, 'y' : 2}, A), "Failed extra key check"
assert not isinstance({'y' : 2}, A), "Failed missing key check"



def try_match_A_or_B(value):
    match value:
        case A():
            return A
        case B():
            return B
        case _:
            return None


assert try_match_A_or_B({"x": 1}) is A
assert try_match_A_or_B({"y": 1}) is B
assert try_match_A_or_B({"x": 1, "z" : 1}) is None  
assert try_match_A_or_B({"z": 1, "y" : 1}) is None  
assert try_match_A_or_B({"z": 1}) is None  

print('All checks passed.')

This does not support TypedDict’s functional syntax, total, Required or NotRequired. I normally avoid metaclass Black Magic too so could’ve made some howling errors. I do not claim this will work with the type spec, let alone specific type checkers.

8

I think the way that runtime_checkable works for Protocol would be less valuable than we might like here, because it doesn’t check types (though it would be more valuable than the current situation).

@runtime_checkable
class A(Protocol):
    x: int

isinstance(a, A)
# This only checks whether the attribute `x` exists, not the type of `x`
9

Thank you everyone for the replies and insightful answers.

I understand that the matching fails because you cannot make instances of typeddicts, fair enough. However, it still surprises me that a typeddict does not behave like a dict (i.e. a mapping) or a mapping pattern. By writting a typeddict, I’m encoding an expected structure, and it would be awesome to be able to use it in a case; otherwise, I end up having to use a dataclass.

10

match should behave as if a typed dict type was just a regular dict, correct? But it doesn’t (in Pyright’s eyes):

image
image818Ă—320 23.5 KB

Running the code prints dict (as expected): `TypedDict` not considered as matching `dict()` pattern in match · Issue #11134 · microsoft/pyright · GitHub

11

This is an important question.

If isinstance(obj, MyTypedDict) was possible, then the following could work:

class MyTypedDict(TypedDict):
    x: int
    y: str

...

match mydict:
    case MyTypedDict(): ...

…and maybe also:

match mydict:
    case MyTypedDict(x=42, y='spam'): ...

The main problem I see with answering that question is how deep such checks should be, i.e., whether not just names (keys) were checked, but also corresponding values’ runtime types (e.g. the type of mydict['x']) [I suppose: yes], and – then – what to do with stuff annotated with not-runtime-checkable constructs (e.g.,list[str]): forbid completely, or limit checks to what is easily runtime-inspectable? (but then: how to delineate usable – clear and intuitive – rules?) :thinking:

***

Perhaps the only (?) viable option is making the feature entirely opt-in, by providing a new decorator (with clear set of rules what would be allowed and how it would be interpreted…) – something along the lines:

@deeply_checkable
class MyTypedDict(TypedDict):
    x: int
    y: list[str]

...

match mydict:
    case MyTypedDict(): ...
    # ^ checks whether this is true:
    #   (isinstance(mydict, dict)
    #    and isinstance(mydict.get('x', MISSING), int)
    #    and isinstance(y := mydict.get('y', MISSING), list)
    #    and all(isinstance(item, str) for item in y))

match mydict:
    case MyTypedDict(x: 42, y=['a', 'b', 'c']): ...
    # ^ checks whether this is true:
    #   (isinstance(mydict, dict)
    #    and isinstance(x := mydict.get('x', MISSING), int)
    #    and x == 42
    #    and isinstance(y := mydict.get('y', MISSING), list)
    #    and all(isinstance(item, str) for item in y)
    #    and list(y) == ['a', 'b', 'c'])

And, perhaps :thinking:, such @deeply_checkabledecorator could even be allowed to be applied to other constructs, e.g., list[str]?

@dataclass
class MyDC:
    x: deeply_checkable(list[str])

…or, perhaps, a related special form were provided to do that, e.g.:

@dataclass
class MyDC:
    x: DeeplyCheckable[list[str]]

But, still, such constructs could not support, e.g., Iterator[str], Generator[str, int], etc. :person_shrugging: