pandas-dev/pandas · error · TypeError

Resolver of type '{name}' does not implement the getitem

Error message

Resolver of type '{name}' does not implement the __getitem__ method

What it means

Raised by _check_resolvers (pandas/core/computation/eval.py:107) as a TypeError when one of the objects passed in the `resolvers` argument (or a default resolver) does not implement __getitem__. Resolvers are the lookup chain eval/query uses to resolve names in the expression; they must behave like mappings supporting square-bracket access, so a non-subscriptable object is rejected.

Source

Thrown at pandas/core/computation/eval.py:107

    parser : str

    Raises
    ------
    KeyError
      * If an invalid parser is passed
    """
    if parser not in PARSERS:
        raise KeyError(
            f"Invalid parser '{parser}' passed, valid parsers are {PARSERS.keys()}"
        )


def _check_resolvers(resolvers) -> None:
    if resolvers is not None:
        for resolver in resolvers:
            if not hasattr(resolver, "__getitem__"):
                name = type(resolver).__name__
                raise TypeError(
                    f"Resolver of type '{name}' does not "
                    "implement the __getitem__ method"
                )


def _check_expression(expr) -> None:
    """
    Make sure an expression is not an empty string

    Parameters
    ----------
    expr : object
        An object that can be converted to a string

    Raises
    ------
    ValueError
      * If expr is an empty string

View on GitHub (pinned to 71959b8cb9)

Solutions

Pass a Mapping-like resolver (dict or collections.abc.Mapping subclass) that supports `resolver[name]`.
Wrap attribute-based namespaces: build a dict `{k: getattr(obj,k) for k in dir(obj)}` and pass that.
Implement __getitem__ on your custom resolver class.

Example fix

# before
pd.eval('a + b', resolvers=[my_object])  # no __getitem__

# after
ns = {'a': my_object.a, 'b': my_object.b}
pd.eval('a + b', resolvers=[ns])

Defensive patterns

Strategy: type-guard

Validate before calling

def validate_resolvers(resolvers):
    for r in (resolvers or []):
        if not hasattr(r, '__getitem__'):
            raise TypeError(f"Resolver {type(r).__name__} must implement __getitem__")
    return resolvers

Type guard

def is_valid_resolver(resolver) -> bool:
    return hasattr(resolver, '__getitem__')

Try / catch

try:
    result = pd.eval('a + b', resolvers=resolvers)
except TypeError as e:
    if 'does not implement the __getitem__' in str(e):
        resolvers = [r if hasattr(r, '__getitem__') else vars(r) for r in resolvers]
        result = pd.eval('a + b', resolvers=resolvers)
    else:
        raise

Prevention

Pass dict or Mapping subclasses as resolvers.
Implement __getitem__ on custom namespace classes.
Convert attribute namespaces to dicts with vars() or a comprehension.

When it happens

Trigger: `pd.eval('a + b', resolvers=[obj])` where obj lacks __getitem__ (e.g. a list, set, bare object, or a custom class without mapping behavior). Also when a library injects a resolver into the evaluation scope that is not a Mapping.

Common situations: Custom resolver classes that forgot to implement __getitem__, passing a list of variables instead of a dict, or integrating eval with a namespace object that is attribute-based rather than item-based.

Related errors

AI-assisted analysis of pandas-dev/pandas@71959b8cb9 (2026-08-07). Data as JSON: /api/errors/df00a55251082c38. Report an issue: GitHub.