How do I use `Expr.in_`?

[hanjinliu]

• app-model version: 0.2.7
• Python version: 3.11.9
• Operating System: Windows 11

Description

The in_ method seems not working with a constant list.
What I wanted to do was to use a ContextNamespace ctx and make a enablement statement like ctx.window_state.in_(["minimized", "maximized"]). I think I can make it work by defining another ContextKey that always returns a constant list, but I think there should be some easier way to do that.

What I Did

expr = Constant(1).in_(Constant(2))  # <- not working, as a constant is not iterable
expr = Constant(1).in_([1, 2])  # <- not working, as a list is not a constant
expr = Constant(1).in_(ast.List(1, 2))  # <- not working, as a ast.List is not a constant

[tlambert03]

might need to see more to help you with your example... but I'm not sure you're thinking about the in_ operator on Expression instance correctly. two observations:

1. in_ the argument passed to in_ must be either an Expr or anything that can be easily cast to an Expr. So, actually, your first example does work fine (in the sense that it's not an exception), but when you try to evaluate it, it's meaningless (because the statement 1 in 2 doesn't make sense)

   In [20]: Constant(1).in_(Constant(2))
   Out[20]: Expr.parse('1 in 2')

2. usually, you would build and evaluate an expression like this:

from app_model.expressions import parse_expression

expr = parse_expression('1 in some_list')

# and then later evaluate it
expr.eval({'some_list': [1, 2]})  # True

so, help me understand your intentions here? What are you trying to check? ctx.window_state.in_(["minimized", "maximized"]) suggests you want an expression that returns true if the window state is either minimized or maximized?

[hanjinliu]

Hi @tlambert03 , thanks for your reply.

Sorry my question was not specific.
I want to use QModelMainWindow and Action to simplify the logic of enabling/disabling menu items according to the application state, such as the window state. Every time the window state changes, the context key ctx.window_state will be updated (to "normal", "minimized", "maximized" or "full") and the context of the menubar will be updated as well.
If I need an Action that will only be enabled when the window is either minimized or maximized, I'll want to define an Action like:

Action(
    id="my-action",
    ...,  # other arguments
    enablement=ctx.window_state.in_(["minimized", "maximized"]),
)

but I could not find a way to use in_ in the enablement argument. As Expr._cast only allows Expr or Constant, maybe a class that inherits both Expr and ast.List is needed for this purpose?

[tlambert03]

ok. then the immediate answer is that there is a limited grammar allowed in app-model expressions. Sets, lists, tuples and other containers aren't yet supported:

In [1]: from app_model.expressions import parse_expression, Name

In [2]: parse_expression('["maximized", "minimized"]')
Traceback (most recent call last):

  File ~/miniforge3/envs/app-model/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3577 in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)

  Cell In[2], line 1
    parse_expression('["maximized", "minimized"]')

  File ~/dev/self/app-model/src/app_model/expressions/_expressions.py:70 in parse_expression
    raise SyntaxError(f"{expr!r} is not a valid expression: ({e}).") from None

  File <string>
SyntaxError: '["maximized", "minimized"]' is not a valid expression: (Type 'List' not supported).

so, for this use case, I would avoid using the container notation and just use joined equality operators:

In [13]: window_state = Name('window_state')

In [14]: (window_state == "minimized") | (window_state == "maximized")
Out[14]: Expr.parse("window_state == 'minimized' or window_state == 'maximized'")

we could look into supporting lists/sets/tuples in expressions. However, their omissions wasn't accidental. The goal was always to support a somewhat minimal grammar, partially for security concerns when parsing arbitrary strings that will be executed. However, if you have a case where you need to add a very large set of literals constants in an expression, we could reconsider that

[hanjinliu]

Thank you for the the explanation and the quick PR! I understand there might be some potential risks with more grammars. For my use case, I think joining equalities is fine.