ruff SIM211

• The condition may have side effects; while evaluation order is preserved, the negation changes the truth value semantics but not execution timing.
• If the condition is a variable named 'not', rewriting could create a syntax error due to keyword conflict (e.g., 'False if not else True' → 'not not' is valid but 'False if not else True' parses as condition='not').
• If the condition uses a walrus operator (e.g., 'False if (x := y) else True'), the rewrite 'not (x := y)' remains valid but alters where the assignment expression is evaluated in larger contexts.
• In a lambda default argument like 'lambda cond=False if x else True: ...', the rewrite to 'lambda cond=not x: ...' preserves behavior but may affect introspection or source display.
• If the expression appears in a statement where the value is ignored (e.g., 'False if x else True; pass'), removing the conditional expression via rewrite does not drop the statement but replaces its value, which is safe since the value was unused.
• If the condition is a comma-separated tuple (e.g., 'False if (a, b) else True'), the rewrite 'not (a, b)' is valid and equivalent since tuple truthiness is preserved under negation.
• If the condition is a slice object (e.g., 'False if s[x:y] else True'), the rewrite 'not s[x:y]' is valid and equivalent because slice objects are always truthy, so both sides evaluate to False and True respectively — wait, no: slice objects are truthy, so 'False if slice else True' is False, and 'not slice' is False — actually equivalent. No hazard here.
• If the condition is a NumPy array, 'not arr' raises ValueError due to ambiguity, whereas the conditional expression would have worked if the array was used in a boolean context only after explicit reduction — but in the original, 'False if arr else True' would already raise ValueError on the condition evaluation, so the rewrite fails at the same point.
• If the condition is a custom object with __bool__ returning an integer subclass where negation behaves differently due to __inv__, but Python's 'not' always coerces to bool first, so it is equivalent.
• If the expression is part of a larger expression and parentheses are omitted relying on operator precedence, the rewrite 'not cond' may bind differently than the original conditional expression (which has low precedence), e.g., in 'False if x else True or y' vs 'not x or y' — but the original parses as (False if x else (True or y))? No: conditional expressions have lower precedence than 'or', so 'False if x else True or y' is (False if x else True) or y, and 'not x or y' is (not x) or y — and since (False if x else True) equals (not x), they are equivalent. So no hazard.

Original: False, Rewritten: False

Original grouped: False, Rewritten: False

After first call: call_count=2, orig=False, rewritten=True
After second call: call_count=4, orig=False, rewritten=True

f1() orig: False, f2() orig: False
List contents: [0, 1], bool: True, not: False

After original: x=5, result=False
After rewritten: x=5, result=False
x value in both cases: 5

finally executed
Caught: ValueError: bad
Now testing rewritten form:
finally executed
Caught: ValueError: bad

Slice: [2, 3], bool: True
Original: False, Rewritten: False
Empty slice: [], orig: True, rewritten: True

Value: 0 (int), orig: True, rewritten: True
Value: 0.0 (float), orig: True, rewritten: True
Value: Decimal('0') (Decimal), orig: True, rewritten: True
Value: 1 (int), orig: False, rewritten: False
Value: 1.0 (float), orig: False, rewritten: False
Value: Decimal('1') (Decimal), orig: False, rewritten: False
Value: -0.0 (float), orig: True, rewritten: True
NaN: orig=False, rewritten=False
All numeric cases equivalent

dict: [(1, False), (2, True)]

f(-1)= True
f(1)= False

lam(): False
source: lam = lambda cond=(False if x else True): cond

got 1
T= False

file contains: b'yes'

list var: [1, 2, 3]
cond: False
built-in list available: True

flag before import: False
flag after simulated * import: True

class x: False
prop accessed
instance prop: False