app_model.expressions #

Bases: Expr[T], BinOp

A binary operation (like addition or division).

op is the operator, and left and right are any expression nodes.

Methods:

• bitand –

  Return bitwise self & other.

• bitor –

  Return bitwise self | other.

• eval –

  Evaluate this expression with names in context.

• in_ –

  Return a comparison for self in other.

• not_in –

  Return a comparison for self no in other.

• parse –

  Parse string into Expr (classmethod).

449
450
451
452
453
454
455
456

def __init__(
    self,
    left: T | Expr[T],
    op: ast.operator,
    right: T | Expr[T],
    **kwargs: Unpack[_Attributes],
) -> None:
    super().__init__(Expr._cast(left), op, Expr._cast(right), **kwargs)

bitand(other: T | Expr[T]) -> BinOp[T]

319
320
321

def bitand(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self & other."""
    return BinOp(self, ast.BitAnd(), other)

bitor(other: T | Expr[T]) -> BinOp[T]

323
324
325

def bitor(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self | other."""
    return BinOp(self, ast.BitOr(), other)

eval(
    context: Mapping[str, object] | None = None,
    **ctx_kwargs: object,
) -> T

203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

def eval(
    self, context: Mapping[str, object] | None = None, **ctx_kwargs: object
) -> T:
    """Evaluate this expression with names in `context`."""
    if context is None:
        context = ctx_kwargs
    elif ctx_kwargs:
        context = {**context, **ctx_kwargs}
    try:
        return eval(self._code, {}, context)  # type: ignore
    except NameError as e:
        miss = {k for k in self._names if k not in context}
        raise NameError(
            f"Names required to eval this expression are missing: {miss}"
        ) from e

in_(other: Any) -> Compare

280
281
282
283

def in_(self, other: Any) -> Compare:
    """Return a comparison for `self` in `other`."""
    # not a dunder, use with Expr.in_(a, other)
    return Compare(self, [ast.In()], [other])

not_in(other: Any) -> Compare

285
286
287

def not_in(self, other: Any) -> Compare:
    """Return a comparison for `self` no in `other`."""
    return Compare(self, [ast.NotIn()], [other])

parse(expr: str) -> Expr

219
220
221
222
223
224
225
226

@classmethod
def parse(cls, expr: str) -> Expr:
    """Parse string into Expr (classmethod).

    see docstring of [`parse_expression`][app_model.expressions.parse_expression]
    for details.
    """
    return parse_expression(expr)

Bases: Expr[T], BoolOp

A boolean operation, 'or' or 'and'.

op is Or or And. values are the values involved. Consecutive operations with the same operator, such as a or b or c, are collapsed into one node with several values.

This doesn't include not, which is a UnaryOp.

Methods:

• bitand –

  Return bitwise self & other.

• bitor –

  Return bitwise self | other.

• eval –

  Evaluate this expression with names in context.

• in_ –

  Return a comparison for self in other.

• not_in –

  Return a comparison for self no in other.

• parse –

  Parse string into Expr (classmethod).

469
470
471
472
473
474
475

def __init__(
    self,
    op: ast.boolop,
    values: Sequence[ConstType | Expr],
    **kwargs: Unpack[_Attributes],
) -> None:
    super().__init__(op, [Expr._cast(v) for v in values], **kwargs)

bitand(other: T | Expr[T]) -> BinOp[T]

319
320
321

def bitand(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self & other."""
    return BinOp(self, ast.BitAnd(), other)

bitor(other: T | Expr[T]) -> BinOp[T]

323
324
325

def bitor(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self | other."""
    return BinOp(self, ast.BitOr(), other)

eval(
    context: Mapping[str, object] | None = None,
    **ctx_kwargs: object,
) -> T

203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

def eval(
    self, context: Mapping[str, object] | None = None, **ctx_kwargs: object
) -> T:
    """Evaluate this expression with names in `context`."""
    if context is None:
        context = ctx_kwargs
    elif ctx_kwargs:
        context = {**context, **ctx_kwargs}
    try:
        return eval(self._code, {}, context)  # type: ignore
    except NameError as e:
        miss = {k for k in self._names if k not in context}
        raise NameError(
            f"Names required to eval this expression are missing: {miss}"
        ) from e

in_(other: Any) -> Compare

280
281
282
283

def in_(self, other: Any) -> Compare:
    """Return a comparison for `self` in `other`."""
    # not a dunder, use with Expr.in_(a, other)
    return Compare(self, [ast.In()], [other])

not_in(other: Any) -> Compare

285
286
287

def not_in(self, other: Any) -> Compare:
    """Return a comparison for `self` no in `other`."""
    return Compare(self, [ast.NotIn()], [other])

parse(expr: str) -> Expr

219
220
221
222
223
224
225
226

@classmethod
def parse(cls, expr: str) -> Expr:
    """Parse string into Expr (classmethod).

    see docstring of [`parse_expression`][app_model.expressions.parse_expression]
    for details.
    """
    return parse_expression(expr)

Bases: Expr[bool], Compare

A comparison of two or more values.

left is the first value in the comparison, ops the list of operators, and comparators the list of values after the first element in the comparison.

Methods:

• bitand –

  Return bitwise self & other.

• bitor –

  Return bitwise self | other.

• eval –

  Evaluate this expression with names in context.

• in_ –

  Return a comparison for self in other.

• not_in –

  Return a comparison for self no in other.

• parse –

  Parse string into Expr (classmethod).

431
432
433
434
435
436
437
438
439
440

def __init__(
    self,
    left: Expr,
    ops: Sequence[ast.cmpop],
    comparators: Sequence[Expr],
    **kwargs: Unpack[_Attributes],
) -> None:
    super().__init__(
        Expr._cast(left), ops, [Expr._cast(c) for c in comparators], **kwargs
    )

bitand(other: T | Expr[T]) -> BinOp[T]

319
320
321

def bitand(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self & other."""
    return BinOp(self, ast.BitAnd(), other)

bitor(other: T | Expr[T]) -> BinOp[T]

323
324
325

def bitor(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self | other."""
    return BinOp(self, ast.BitOr(), other)

eval(
    context: Mapping[str, object] | None = None,
    **ctx_kwargs: object,
) -> T

203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

def eval(
    self, context: Mapping[str, object] | None = None, **ctx_kwargs: object
) -> T:
    """Evaluate this expression with names in `context`."""
    if context is None:
        context = ctx_kwargs
    elif ctx_kwargs:
        context = {**context, **ctx_kwargs}
    try:
        return eval(self._code, {}, context)  # type: ignore
    except NameError as e:
        miss = {k for k in self._names if k not in context}
        raise NameError(
            f"Names required to eval this expression are missing: {miss}"
        ) from e

in_(other: Any) -> Compare

280
281
282
283

def in_(self, other: Any) -> Compare:
    """Return a comparison for `self` in `other`."""
    # not a dunder, use with Expr.in_(a, other)
    return Compare(self, [ast.In()], [other])

not_in(other: Any) -> Compare

285
286
287

def not_in(self, other: Any) -> Compare:
    """Return a comparison for `self` no in `other`."""
    return Compare(self, [ast.NotIn()], [other])

parse(expr: str) -> Expr

219
220
221
222
223
224
225
226

@classmethod
def parse(cls, expr: str) -> Expr:
    """Parse string into Expr (classmethod).

    see docstring of [`parse_expression`][app_model.expressions.parse_expression]
    for details.
    """
    return parse_expression(expr)

Bases: Expr[V], Constant

A constant value.

Parameters:

• value (V) –

  the Python object this constant represents. Types supported: NoneType, str, bytes, bool, int, float

• kind (str | None, default: None ) –

  The kind of constant. This is used to provide type hints when

Methods:

• bitand –

  Return bitwise self & other.

• bitor –

  Return bitwise self | other.

• eval –

  Evaluate this expression with names in context.

• in_ –

  Return a comparison for self in other.

• not_in –

  Return a comparison for self no in other.

• parse –

  Parse string into Expr (classmethod).

414
415
416
417
418
419
420

def __init__(
    self, value: V, kind: str | None = None, **kwargs: Unpack[_Attributes]
) -> None:
    _valid_type = (type(None), str, bytes, bool, int, float)
    if not isinstance(value, _valid_type):
        raise TypeError(f"Constants must be type: {_valid_type!r}")
    super().__init__(value, kind, **kwargs)

bitand(other: T | Expr[T]) -> BinOp[T]

319
320
321

def bitand(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self & other."""
    return BinOp(self, ast.BitAnd(), other)

bitor(other: T | Expr[T]) -> BinOp[T]

323
324
325

def bitor(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self | other."""
    return BinOp(self, ast.BitOr(), other)

eval(
    context: Mapping[str, object] | None = None,
    **ctx_kwargs: object,
) -> T

203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

def eval(
    self, context: Mapping[str, object] | None = None, **ctx_kwargs: object
) -> T:
    """Evaluate this expression with names in `context`."""
    if context is None:
        context = ctx_kwargs
    elif ctx_kwargs:
        context = {**context, **ctx_kwargs}
    try:
        return eval(self._code, {}, context)  # type: ignore
    except NameError as e:
        miss = {k for k in self._names if k not in context}
        raise NameError(
            f"Names required to eval this expression are missing: {miss}"
        ) from e

in_(other: Any) -> Compare

280
281
282
283

def in_(self, other: Any) -> Compare:
    """Return a comparison for `self` in `other`."""
    # not a dunder, use with Expr.in_(a, other)
    return Compare(self, [ast.In()], [other])

not_in(other: Any) -> Compare

285
286
287

def not_in(self, other: Any) -> Compare:
    """Return a comparison for `self` no in `other`."""
    return Compare(self, [ast.NotIn()], [other])

parse(expr: str) -> Expr

219
220
221
222
223
224
225
226

@classmethod
def parse(cls, expr: str) -> Expr:
    """Parse string into Expr (classmethod).

    see docstring of [`parse_expression`][app_model.expressions.parse_expression]
    for details.
    """
    return parse_expression(expr)

Bases: ChainMap

Evented Mapping of keys to values.

Methods:

• buffered_changes –

  Context in which to accumulated changes before emitting.

• new_child –

  Create a new child context from this one.

Attributes:

• changed –

  Event emitted (with a set of changed keys) whenever the context is changed.

34
35
36
37
38

def __init__(self, *maps: MutableMapping) -> None:
    super().__init__(*maps)
    for m in maps:
        if isinstance(m, Context):
            m.changed.connect(self.changed)

changed = Signal(set)

buffered_changes() -> Iterator[None]

40
41
42
43
44

@contextmanager
def buffered_changes(self) -> Iterator[None]:
    """Context in which to accumulated changes before emitting."""
    with self.changed.paused(lambda a, b: (a[0].union(b[0]),)):
        yield

new_child(m: MutableMapping | None = None) -> Context

58
59
60
61
62

def new_child(self, m: MutableMapping | None = None) -> Context:
    """Create a new child context from this one."""
    new = super().new_child(m=m)
    self.changed.connect(new.changed)
    return new

Bases: Name, Generic[A, T]

Context key name, default, description, and getter.

This is intended to be used as class attribute in a ContextNamespace. This is a subclass of Name, and is therefore usable in an Expression. (see examples.)

Parameters:

• default_value (Any, default: MISSING ) –

  The default value for this key, by default MISSING

• description (str, default: None ) –

  Description of this key. Useful for documentation, by default None

• getter (callable, default: None ) –

  Callable that receives an object and retrieves the current value for this key, by default None. For example, if this ContextKey represented the length of some list, (like the layerlist) it might look like length = ContextKey(0, 'length of the list', lambda x: len(x))

• id (str, default: '' ) –

  Explicitly provide the Name string used when evaluating a context, by default the key will be taken as the attribute name to which this object is assigned as a class attribute:

Examples:

>>> class MyNames(ContextNamespace):
...     some_key = ContextKey(0, "some description", lambda x: sum(x))

>>> expr = MyNames.some_key > 5  # create an expression using this key

these expressions can be later evaluated with some concrete context.

>>> expr.eval({"some_key": 3})  # False
>>> expr.eval({"some_key": 6})  # True

Methods:

• bitand –

  Return bitwise self & other.

• bitor –

  Return bitwise self | other.

• eval –

  Evaluate this expression with names in context.

• in_ –

  Return a comparison for self in other.

• info –

  Return list of all stored context keys.

• not_in –

  Return a comparison for self no in other.

• parse –

  Parse string into Expr (classmethod).

 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109

def __init__(
    self,
    default_value: T | __missing = MISSING,
    description: str | None = None,
    getter: Callable[[A], T] | None = None,
    *,
    id: str = "",  # optional because of __set_name__
) -> None:
    bound = type(default_value) if default_value is not MISSING else None
    super().__init__(id or "", bound=bound)
    self._default_value = default_value
    self._getter = getter
    self._description = description
    self._owner: type[ContextNamespace] | None = None
    self._type = (
        type(default_value) if default_value not in (None, MISSING) else None
    )
    if id:
        self._store()

bitand(other: T | Expr[T]) -> BinOp[T]

319
320
321

def bitand(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self & other."""
    return BinOp(self, ast.BitAnd(), other)

bitor(other: T | Expr[T]) -> BinOp[T]

323
324
325

def bitor(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self | other."""
    return BinOp(self, ast.BitOr(), other)

eval(
    context: Mapping[str, object] | None = None,
    **ctx_kwargs: object,
) -> T

203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

def eval(
    self, context: Mapping[str, object] | None = None, **ctx_kwargs: object
) -> T:
    """Evaluate this expression with names in `context`."""
    if context is None:
        context = ctx_kwargs
    elif ctx_kwargs:
        context = {**context, **ctx_kwargs}
    try:
        return eval(self._code, {}, context)  # type: ignore
    except NameError as e:
        miss = {k for k in self._names if k not in context}
        raise NameError(
            f"Names required to eval this expression are missing: {miss}"
        ) from e

in_(other: Any) -> Compare

280
281
282
283

def in_(self, other: Any) -> Compare:
    """Return a comparison for `self` in `other`."""
    # not a dunder, use with Expr.in_(a, other)
    return Compare(self, [ast.In()], [other])

info() -> list[ContextKeyInfo]

114
115
116
117

@classmethod
def info(cls) -> list[ContextKeyInfo]:
    """Return list of all stored context keys."""
    return list(cls._info)

not_in(other: Any) -> Compare

285
286
287

def not_in(self, other: Any) -> Compare:
    """Return a comparison for `self` no in `other`."""
    return Compare(self, [ast.NotIn()], [other])

parse(expr: str) -> Expr

219
220
221
222
223
224
225
226

@classmethod
def parse(cls, expr: str) -> Expr:
    """Parse string into Expr (classmethod).

    see docstring of [`parse_expression`][app_model.expressions.parse_expression]
    for details.
    """
    return parse_expression(expr)

Bases: NamedTuple

Just a recordkeeping tuple.

Retrieve all declared ContextKeys with ContextKeyInfo.info().

Parameters:

• key (ForwardRef('str'), default: None ) –
• type (ForwardRef('type | None'), default: None ) –
• description (ForwardRef('str | None'), default: None ) –
• namespace (ForwardRef('builtins.type[ContextNamespace] | None'), default: None ) –

Bases: Generic[A]

A collection of related keys in a context.

meant to be subclassed, with ContextKeys as class attributes.

Methods:

• dict –

  Return all keys in this namespace.

• reset –

  Reset keys to its default.

• reset_all –

  Reset all keys to their defaults.

197
198
199
200
201
202
203
204
205
206
207
208
209

def __init__(self, context: MutableMapping) -> None:
    self._context = context

    # on instantiation we create an index of defaults and value-getters
    # to speed up retrieval later
    self._defaults: dict[str, Any] = {}  # default values per key
    self._getters: dict[str, Callable[[A], Any]] = {}  # value getters
    for name, ctxkey in type(self).__members__.items():
        self._defaults[name] = ctxkey._default_value
        if ctxkey._default_value is not MISSING:
            context[ctxkey.id] = ctxkey._default_value
        if callable(ctxkey._getter):
            self._getters[name] = ctxkey._getter

dict() -> dict

225
226
227

def dict(self) -> dict:
    """Return all keys in this namespace."""
    return {k: getattr(self, k) for k in type(self).__members__}

reset(key: str) -> None

211
212
213
214
215
216
217
218

def reset(self, key: str) -> None:
    """Reset keys to its default."""
    val = self._defaults[key]
    if val is MISSING:
        with contextlib.suppress(KeyError):
            delattr(self, key)
    else:
        setattr(self, key, self._defaults[key])

reset_all() -> None

220
221
222
223

def reset_all(self) -> None:
    """Reset all keys to their defaults."""
    for key in self._defaults:
        self.reset(key)

Bases: AST, Generic[T]

Base Expression class providing dunder and convenience methods.

This is a subclass of ast.AST that provides rich dunder methods that facilitate joining and comparing typed expressions. It only implements a subset of ast Expressions (for safety of evaluation), but provides more than ast.literal_eval.

Expressions that are supported:

• Names: 'myvar' (these must be evaluated along with some context)
• Constants: '1'
• Comparisons: 'myvar > 1'
• Boolean Operators: 'myvar & yourvar' (bitwise & and | are overloaded here to mean boolean and and or)
• Binary Operators: 'myvar + 42' (includes //, @, ^)
• Unary Operators: 'not myvar'

Things that are NOT supported:

• attribute access: 'my.attr'
• calls: 'f(x)'
• containers (lists, tuples, sets, dicts)
• indexing or slicing
• joined strings (f-strings)
• named expressions (walrus operator)
• comprehensions (list, set, dict, generator)
• statements & assignments (e.g. 'a = b')

This class is not meant to be instantiated directly. Instead, use parse_expression, or the Expr.parse classmethod to create an expression instance.

Once created, an expression can be joined with other expressions, or constants.

Examples:

>>> expr = parse_expression("myvar > 5")

combine expressions with operators

>>> new_expr = expr & parse_expression("v2")

nice repr

>>> new_expr
BoolOp(
    op=And(),
    values=[
        Compare(
        left=Name(id='myvar', ctx=Load()),
        ops=[
            Gt()],
        comparators=[
            Constant(value=5)]),
        Name(id='v2', ctx=Load())])

evaluate in some context

>>> new_expr.eval(dict(v2="hello!", myvar=8))
'hello!'

you can also use keyword arguments. This is slightly slower

>>> new_expr.eval(v2="hello!", myvar=4)

serialize

>>> str(new_expr)
'myvar > 5 and v2'

One reason you might want to use this object is to capture named expressions that can be evaluated repeatedly as some underlying context changes.

light_is_green = Name[bool]("light_is_green")
count = Name[int]("count")
is_ready = light_is_green & count > 5

assert is_ready.eval({"count": 4, "light_is_green": True}) == False
assert is_ready.eval({"count": 7, "light_is_green": False}) == False
assert is_ready.eval({"count": 7, "light_is_green": True}) == True

this will also preserve type information:

>>> reveal_type(is_ready())  # revealed type is `bool`

Methods:

• bitand –

  Return bitwise self & other.

• bitor –

  Return bitwise self | other.

• eval –

  Evaluate this expression with names in context.

• in_ –

  Return a comparison for self in other.

• not_in –

  Return a comparison for self no in other.

• parse –

  Parse string into Expr (classmethod).

192
193
194
195
196

def __init__(self, *args: Any, **kwargs: Any) -> None:
    if type(self).__name__ == "Expr":
        raise RuntimeError("Don't instantiate Expr. Use `Expr.parse`")
    super().__init__(*args, **kwargs)
    self._recompile()

bitand(other: T | Expr[T]) -> BinOp[T]

319
320
321

def bitand(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self & other."""
    return BinOp(self, ast.BitAnd(), other)

bitor(other: T | Expr[T]) -> BinOp[T]

323
324
325

def bitor(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self | other."""
    return BinOp(self, ast.BitOr(), other)

eval(
    context: Mapping[str, object] | None = None,
    **ctx_kwargs: object,
) -> T

203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

def eval(
    self, context: Mapping[str, object] | None = None, **ctx_kwargs: object
) -> T:
    """Evaluate this expression with names in `context`."""
    if context is None:
        context = ctx_kwargs
    elif ctx_kwargs:
        context = {**context, **ctx_kwargs}
    try:
        return eval(self._code, {}, context)  # type: ignore
    except NameError as e:
        miss = {k for k in self._names if k not in context}
        raise NameError(
            f"Names required to eval this expression are missing: {miss}"
        ) from e

in_(other: Any) -> Compare

280
281
282
283

def in_(self, other: Any) -> Compare:
    """Return a comparison for `self` in `other`."""
    # not a dunder, use with Expr.in_(a, other)
    return Compare(self, [ast.In()], [other])

not_in(other: Any) -> Compare

285
286
287

def not_in(self, other: Any) -> Compare:
    """Return a comparison for `self` no in `other`."""
    return Compare(self, [ast.NotIn()], [other])

parse(expr: str) -> Expr

219
220
221
222
223
224
225
226

@classmethod
def parse(cls, expr: str) -> Expr:
    """Parse string into Expr (classmethod).

    see docstring of [`parse_expression`][app_model.expressions.parse_expression]
    for details.
    """
    return parse_expression(expr)

Bases: Expr, IfExp

An expression such as 'a if b else c'.

body if test else orelse

Methods:

• bitand –

  Return bitwise self & other.

• bitor –

  Return bitwise self | other.

• eval –

  Evaluate this expression with names in context.

• in_ –

  Return a comparison for self in other.

• not_in –

  Return a comparison for self no in other.

• parse –

  Parse string into Expr (classmethod).

496
497
498
499
500
501

def __init__(
    self, test: Expr, body: Expr, orelse: Expr, **kwargs: Unpack[_Attributes]
) -> None:
    super().__init__(
        Expr._cast(test), Expr._cast(body), Expr._cast(orelse), **kwargs
    )

bitand(other: T | Expr[T]) -> BinOp[T]

319
320
321

def bitand(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self & other."""
    return BinOp(self, ast.BitAnd(), other)

bitor(other: T | Expr[T]) -> BinOp[T]

323
324
325

def bitor(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self | other."""
    return BinOp(self, ast.BitOr(), other)

eval(
    context: Mapping[str, object] | None = None,
    **ctx_kwargs: object,
) -> T

203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

def eval(
    self, context: Mapping[str, object] | None = None, **ctx_kwargs: object
) -> T:
    """Evaluate this expression with names in `context`."""
    if context is None:
        context = ctx_kwargs
    elif ctx_kwargs:
        context = {**context, **ctx_kwargs}
    try:
        return eval(self._code, {}, context)  # type: ignore
    except NameError as e:
        miss = {k for k in self._names if k not in context}
        raise NameError(
            f"Names required to eval this expression are missing: {miss}"
        ) from e

in_(other: Any) -> Compare

280
281
282
283

def in_(self, other: Any) -> Compare:
    """Return a comparison for `self` in `other`."""
    # not a dunder, use with Expr.in_(a, other)
    return Compare(self, [ast.In()], [other])

not_in(other: Any) -> Compare

285
286
287

def not_in(self, other: Any) -> Compare:
    """Return a comparison for `self` no in `other`."""
    return Compare(self, [ast.NotIn()], [other])

parse(expr: str) -> Expr

219
220
221
222
223
224
225
226

@classmethod
def parse(cls, expr: str) -> Expr:
    """Parse string into Expr (classmethod).

    see docstring of [`parse_expression`][app_model.expressions.parse_expression]
    for details.
    """
    return parse_expression(expr)

Bases: Expr[T], Name

A variable name.

Parameters:

• id (str) –

  The name of the variable.

• bound (Any | None, default: None ) –

  The type of the variable represented by this name (i.e. the type to which this name evaluates to when used in an expression). This is used to provide type hints when evaluating the expression. If None, the type is not known.

Methods:

• bitand –

  Return bitwise self & other.

• bitor –

  Return bitwise self | other.

• eval –

  Evaluate this expression with names in context.

• in_ –

  Return a comparison for self in other.

• not_in –

  Return a comparison for self no in other.

• parse –

  Parse string into Expr (classmethod).

388
389
390
391
392
393
394
395
396
397

def __init__(
    self,
    id: str,
    ctx: ast.expr_context = LOAD,
    *,
    bound: type[T] | None = None,
    **kwargs: Unpack[_Attributes],
) -> None:
    super().__init__(id, ctx=ctx, **kwargs)
    self.bound = bound

bitand(other: T | Expr[T]) -> BinOp[T]

319
320
321

def bitand(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self & other."""
    return BinOp(self, ast.BitAnd(), other)

bitor(other: T | Expr[T]) -> BinOp[T]

323
324
325

def bitor(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self | other."""
    return BinOp(self, ast.BitOr(), other)

eval(
    context: Mapping[str, object] | None = None,
    **ctx_kwargs: object,
) -> T

203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

def eval(
    self, context: Mapping[str, object] | None = None, **ctx_kwargs: object
) -> T:
    """Evaluate this expression with names in `context`."""
    if context is None:
        context = ctx_kwargs
    elif ctx_kwargs:
        context = {**context, **ctx_kwargs}
    try:
        return eval(self._code, {}, context)  # type: ignore
    except NameError as e:
        miss = {k for k in self._names if k not in context}
        raise NameError(
            f"Names required to eval this expression are missing: {miss}"
        ) from e

in_(other: Any) -> Compare

280
281
282
283

def in_(self, other: Any) -> Compare:
    """Return a comparison for `self` in `other`."""
    # not a dunder, use with Expr.in_(a, other)
    return Compare(self, [ast.In()], [other])

not_in(other: Any) -> Compare

285
286
287

def not_in(self, other: Any) -> Compare:
    """Return a comparison for `self` no in `other`."""
    return Compare(self, [ast.NotIn()], [other])

parse(expr: str) -> Expr

219
220
221
222
223
224
225
226

@classmethod
def parse(cls, expr: str) -> Expr:
    """Parse string into Expr (classmethod).

    see docstring of [`parse_expression`][app_model.expressions.parse_expression]
    for details.
    """
    return parse_expression(expr)

Bases: Expr[T], UnaryOp

A unary operation.

op is the operator, and operand any expression node.

Methods:

• bitand –

  Return bitwise self & other.

• bitor –

  Return bitwise self | other.

• eval –

  Evaluate this expression with names in context.

• in_ –

  Return a comparison for self in other.

• not_in –

  Return a comparison for self no in other.

• parse –

  Parse string into Expr (classmethod).

484
485
486
487

def __init__(
    self, op: ast.unaryop, operand: Expr, **kwargs: Unpack[_Attributes]
) -> None:
    super().__init__(op, Expr._cast(operand), **kwargs)

bitand(other: T | Expr[T]) -> BinOp[T]

319
320
321

def bitand(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self & other."""
    return BinOp(self, ast.BitAnd(), other)

bitor(other: T | Expr[T]) -> BinOp[T]

323
324
325

def bitor(self, other: T | Expr[T]) -> BinOp[T]:
    """Return bitwise self | other."""
    return BinOp(self, ast.BitOr(), other)

eval(
    context: Mapping[str, object] | None = None,
    **ctx_kwargs: object,
) -> T

203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

def eval(
    self, context: Mapping[str, object] | None = None, **ctx_kwargs: object
) -> T:
    """Evaluate this expression with names in `context`."""
    if context is None:
        context = ctx_kwargs
    elif ctx_kwargs:
        context = {**context, **ctx_kwargs}
    try:
        return eval(self._code, {}, context)  # type: ignore
    except NameError as e:
        miss = {k for k in self._names if k not in context}
        raise NameError(
            f"Names required to eval this expression are missing: {miss}"
        ) from e

in_(other: Any) -> Compare

280
281
282
283

def in_(self, other: Any) -> Compare:
    """Return a comparison for `self` in `other`."""
    # not a dunder, use with Expr.in_(a, other)
    return Compare(self, [ast.In()], [other])

not_in(other: Any) -> Compare

285
286
287

def not_in(self, other: Any) -> Compare:
    """Return a comparison for `self` no in `other`."""
    return Compare(self, [ast.NotIn()], [other])

parse(expr: str) -> Expr

219
220
221
222
223
224
225
226

@classmethod
def parse(cls, expr: str) -> Expr:
    """Parse string into Expr (classmethod).

    see docstring of [`parse_expression`][app_model.expressions.parse_expression]
    for details.
    """
    return parse_expression(expr)