superacli 1.1.6 → 1.1.7

package/ref-monty/crates/monty/test_cases/unpack__not_enough.py

@@ -1,9 +0,0 @@
-a, b, c = (1, 2)
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "unpack__not_enough.py", line 1, in <module>
-    a, b, c = (1, 2)
-    ~~~~~~~
-ValueError: not enough values to unpack (expected 3, got 2)
-"""

package/ref-monty/crates/monty/test_cases/unpack__ops.py

@@ -1,153 +0,0 @@
-# === Basic tuple unpacking ===
-a, b = (1, 2)
-assert a == 1, 'first element of tuple'
-assert b == 2, 'second element of tuple'
-
-# === Unpacking without parentheses ===
-x, y = 10, 20
-assert x == 10, 'first element without parens'
-assert y == 20, 'second element without parens'
-
-# === Three element unpacking ===
-a, b, c = (1, 2, 3)
-assert a == 1, 'three elements: first'
-assert b == 2, 'three elements: second'
-assert c == 3, 'three elements: third'
-
-
-# === Unpacking from function return ===
-def returns_pair():
-    return 42, 37
-
-
-x, y = returns_pair()
-assert x == 42, 'function return first'
-assert y == 37, 'function return second'
-
-
-def returns_triple():
-    return 'a', 'b', 'c'
-
-
-p, q, r = returns_triple()
-assert p == 'a', 'function return triple first'
-assert q == 'b', 'function return triple second'
-assert r == 'c', 'function return triple third'
-
-# === Unpacking list ===
-a, b = [100, 200]
-assert a == 100, 'list unpack first'
-assert b == 200, 'list unpack second'
-
-a, b, c, d = [1, 2, 3, 4]
-assert a == 1, 'four element list first'
-assert d == 4, 'four element list fourth'
-
-# === Unpacking string ===
-a, b = 'xy'
-assert a == 'x', 'string unpack first char'
-assert b == 'y', 'string unpack second char'
-
-p, q, r = 'abc'
-assert p == 'a', 'three char string first'
-assert q == 'b', 'three char string second'
-assert r == 'c', 'three char string third'
-
-# === Unpacking with different value types ===
-a, b = (True, False)
-assert a is True, 'bool tuple first'
-assert b is False, 'bool tuple second'
-
-a, b = (1.5, 2.5)
-assert a == 1.5, 'float tuple first'
-assert b == 2.5, 'float tuple second'
-
-a, b = (None, 42)
-assert a is None, 'mixed tuple None'
-assert b == 42, 'mixed tuple int'
-
-# === Unpacking with nested containers ===
-a, b = ([1, 2], [3, 4])
-assert a == [1, 2], 'nested list first'
-assert b == [3, 4], 'nested list second'
-
-a, b = ((1, 2), (3, 4))
-assert a == (1, 2), 'nested tuple first'
-assert b == (3, 4), 'nested tuple second'
-
-# === Reassignment via unpacking ===
-x = 1
-y = 2
-x, y = y, x
-assert x == 2, 'swap first'
-assert y == 1, 'swap second'
-
-# === Single element tuple (edge case) ===
-# Note: (x,) = (1,) is valid Python
-(a,) = (42,)
-assert a == 42, 'single element tuple unpack'
-
-(a,) = [99]
-assert a == 99, 'single element list unpack'
-
-(a,) = 'z'
-assert a == 'z', 'single char string unpack'
-
-# === Star unpacking (extended unpacking) ===
-# Star at end
-first, *rest = [1, 2, 3, 4, 5]
-assert first == 1, 'star at end: first'
-assert rest == [2, 3, 4, 5], 'star at end: rest'
-
-# Star at start
-*init, last = [1, 2, 3, 4, 5]
-assert init == [1, 2, 3, 4], 'star at start: init'
-assert last == 5, 'star at start: last'
-
-# Star in middle
-first, *middle, last = [1, 2, 3, 4, 5]
-assert first == 1, 'star in middle: first'
-assert middle == [2, 3, 4], 'star in middle: middle'
-assert last == 5, 'star in middle: last'
-
-# Empty rest (minimum values)
-first, *rest, last = [1, 2]
-assert first == 1, 'empty rest: first'
-assert rest == [], 'empty rest: rest is empty list'
-assert last == 2, 'empty rest: last'
-
-# From tuple
-a, *b = (10, 20, 30)
-assert a == 10, 'star from tuple: a'
-assert b == [20, 30], 'star from tuple: b is list'
-
-# From string
-first, *mid, last = 'abcde'
-assert first == 'a', 'star from string: first'
-assert mid == ['b', 'c', 'd'], 'star from string: mid'
-assert last == 'e', 'star from string: last'
-
-# With more targets before star
-a, b, c, *rest = [1, 2, 3, 4, 5, 6]
-assert a == 1, 'multiple before star: a'
-assert b == 2, 'multiple before star: b'
-assert c == 3, 'multiple before star: c'
-assert rest == [4, 5, 6], 'multiple before star: rest'
-
-# With more targets after star
-*init, x, y, z = [1, 2, 3, 4, 5, 6]
-assert init == [1, 2, 3], 'multiple after star: init'
-assert x == 4, 'multiple after star: x'
-assert y == 5, 'multiple after star: y'
-assert z == 6, 'multiple after star: z'
-
-# Star captures all but one
-head, *tail = [1]
-assert head == 1, 'single item: head'
-assert tail == [], 'single item: tail is empty'
-
-# Star with bracket syntax
-[a, *b, c] = [1, 2, 3, 4]
-assert a == 1, 'bracket syntax: a'
-assert b == [2, 3], 'bracket syntax: b'
-assert c == 4, 'bracket syntax: c'

package/ref-monty/crates/monty/test_cases/unpack__star_not_enough.py

@@ -1,9 +0,0 @@
-a, *b, c = [1]
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "unpack__star_not_enough.py", line 1, in <module>
-    a, *b, c = [1]
-    ~~~~~~~~
-ValueError: not enough values to unpack (expected at least 2, got 1)
-"""

package/ref-monty/crates/monty/test_cases/unpack__too_many.py

@@ -1,9 +0,0 @@
-a, b = (1, 2, 3, 4, 5)
-"""
-TRACEBACK:
-Traceback (most recent call last):
-  File "unpack__too_many.py", line 1, in <module>
-    a, b = (1, 2, 3, 4, 5)
-    ~~~~
-ValueError: too many values to unpack (expected 2, got 5)
-"""

package/ref-monty/crates/monty/test_cases/version__cpython.py

@@ -1,4 +0,0 @@
-import sys
-
-v = sys.version_info
-assert (v[0], v[1]) == (3, 14), f'Expected Python 3.14, got ({v[0]}, {v[1]})'

package/ref-monty/crates/monty/test_cases/walrus__all.py

@@ -1,178 +0,0 @@
-# === Basic walrus operator ===
-# Simple assignment expression
-assert (x := 5) == 5, 'walrus returns value'
-assert x == 5, 'walrus assigns to variable'
-
-# Walrus in parentheses
-y = (z := 10)
-assert y == 10, 'walrus value can be assigned'
-assert z == 10, 'walrus target is assigned'
-
-# simple if
-x = None
-answer = 'unset'
-if y := x:
-    answer = f'x is {y}'
-
-assert answer == 'unset'
-
-x = 123
-if y := x:
-    answer = f'x is {y}'
-
-assert answer == 'x is 123'
-x = 0
-if y := x:
-    answer = f'x is {y}'
-else:
-    answer = 'x is unset'
-
-assert answer == 'x is unset'
-
-# === Walrus in if conditions ===
-if (a := 3) > 0:
-    assert a == 3, 'walrus in if test'
-else:
-    assert False, 'should not reach else'
-
-# With falsy value
-if b := 0:
-    assert False, 'should not reach truthy branch'
-else:
-    assert b == 0, 'walrus assigns even when falsy'
-
-# === Walrus in while loops ===
-counter = 0
-result = []
-while (n := counter) < 3:
-    result.append(n)
-    counter += 1
-assert result == [0, 1, 2], 'walrus in while condition'
-assert n == 3, 'walrus value persists after while'
-
-# === Nested walrus ===
-# Inner walrus assigned first, then outer
-assert (outer := (inner := 7) + 1) == 8, 'nested walrus returns correct value'
-assert inner == 7, 'inner walrus assigned'
-assert outer == 8, 'outer walrus assigned'
-
-# === Walrus in list literals ===
-items = [(v := 1), v + 1, v + 2]
-assert items == [1, 2, 3], 'walrus in list literal'
-assert v == 1, 'walrus variable accessible after list'
-
-# === Walrus in ternary expressions ===
-result = (t := 5) if True else 0
-assert result == 5, 'walrus in ternary truthy branch'
-assert t == 5, 'walrus assigned in ternary'
-
-result2 = 0 if False else (f := 6)
-assert result2 == 6, 'walrus in ternary falsy branch'
-assert f == 6, 'walrus assigned in falsy branch'
-
-# === Walrus in dict/set literals ===
-d = {(k := 'key'): (val := 42)}
-assert d == {'key': 42}, 'walrus in dict literal'
-assert k == 'key', 'walrus key assigned'
-assert val == 42, 'walrus value assigned'
-
-s = {(s1 := 1), (s2 := 2)}
-assert s == {1, 2}, 'walrus in set literal'
-assert s1 == 1, 'walrus in set element 1'
-assert s2 == 2, 'walrus in set element 2'
-
-# === Walrus in subscript expressions ===
-arr = [10, 20, 30]
-value = arr[(idx := 1)]
-assert value == 20, 'walrus in subscript index'
-assert idx == 1, 'walrus index assigned'
-
-
-# === Walrus in function calls ===
-def identity(x):
-    return x
-
-
-result = identity((arg := 99))
-assert result == 99, 'walrus in function argument'
-assert arg == 99, 'walrus arg assigned'
-
-# === Walrus with comparison operators ===
-assert (cmp := 10) > 5, 'walrus in comparison'
-assert cmp == 10, 'walrus assigned in comparison'
-
-# === Walrus in chained comparisons ===
-# Note: Chained comparisons like `0 < (mid := 5) < 10` are not yet supported
-# Testing a simpler comparison chain
-mid = (chain := 5)
-assert 0 < chain and chain < 10, 'walrus result used in comparison chain'
-assert mid == 5, 'walrus assigned correctly'
-
-# === Walrus in boolean expressions ===
-# Short-circuit with and
-result = (first := 1) and (second := 2)
-assert result == 2, 'walrus in and expression'
-assert first == 1, 'first walrus assigned'
-assert second == 2, 'second walrus assigned (and evaluated)'
-
-# Short-circuit with or (second not evaluated)
-result = (or_first := 1) or (or_skip := 999)
-assert result == 1, 'walrus in or expression (short-circuit)'
-assert or_first == 1, 'or first walrus assigned'
-
-# === Walrus with operations ===
-assert (op := 3) + 2 == 5, 'walrus with addition'
-assert op == 3, 'walrus assigned before operation'
-
-# === Walrus in f-strings ===
-msg = f'{(fvar := "hello")} world'
-assert msg == 'hello world', 'walrus in f-string'
-assert fvar == 'hello', 'walrus assigned in f-string'
-
-# === Walrus with global ===
-global_var = None
-
-
-def set_global():
-    global global_var
-    return (global_var := 'set')
-
-
-result = set_global()
-assert result == 'set', 'walrus with global returns value'
-assert global_var == 'set', 'global var assigned via walrus'
-
-
-# === Walrus creates local in function scope ===
-def func_scope():
-    if local := 42:
-        pass
-    return local
-
-
-assert func_scope() == 42, 'walrus creates local in function'
-
-# === Walrus in list comprehension element (leaks to enclosing scope) ===
-# Per PEP 572, walrus in comprehension assigns to enclosing scope
-# Note: walrus in comprehension iterable is not allowed, but in element/condition it is
-result = [(leak := x) for x in range(3)]
-assert result == [0, 1, 2], 'walrus in comprehension element'
-assert leak == 2, 'walrus in comprehension leaks to enclosing scope'
-
-# === Walrus in comprehension condition ===
-result = [x for x in range(5) if (limit := 3) and x < limit]
-assert result == [0, 1, 2], 'walrus in comprehension condition'
-assert limit == 3, 'walrus from comprehension condition accessible'
-
-# === Multiple walrus in same expression ===
-result = (m1 := 1) + (m2 := 2) + (m3 := 3)
-assert result == 6, 'multiple walrus in expression'
-assert m1 == 1, 'first multi-walrus'
-assert m2 == 2, 'second multi-walrus'
-assert m3 == 3, 'third multi-walrus'
-
-# === Walrus in tuple ===
-tup = ((t1 := 'a'), (t2 := 'b'))
-assert tup == ('a', 'b'), 'walrus in tuple'
-assert t1 == 'a', 'first tuple walrus'
-assert t2 == 'b', 'second tuple walrus'

package/ref-monty/crates/monty/test_cases/while__all.py

@@ -1,206 +0,0 @@
-# === Basic while loop ===
-i = 0
-result = []
-while i < 3:
-    result.append(i)
-    i += 1
-assert result == [0, 1, 2], 'basic while loop'
-
-# === While with break ===
-i = 0
-result = []
-while i < 10:
-    if i == 3:
-        break
-    result.append(i)
-    i += 1
-assert result == [0, 1, 2], 'while with break'
-
-# === While with continue ===
-i = 0
-result = []
-while i < 5:
-    i += 1
-    if i % 2 == 0:
-        continue
-    result.append(i)
-assert result == [1, 3, 5], 'while with continue'
-
-# === While with else (no break - else runs) ===
-i = 0
-flag = 0
-while i < 3:
-    i += 1
-else:
-    flag = 1
-assert flag == 1, 'while else runs when no break'
-
-# === While with else (with break - else skipped) ===
-i = 0
-flag = 0
-while i < 10:
-    i += 1
-    if i == 2:
-        break
-else:
-    flag = 1
-assert flag == 0, 'while else skipped on break'
-
-# === while True with break ===
-i = 0
-result = []
-while True:
-    result.append(i)
-    i += 1
-    if i >= 3:
-        break
-assert result == [0, 1, 2], 'while True with break'
-
-# === while False (never executes) ===
-flag = 0
-while False:
-    flag = 1
-assert flag == 0, 'while False never executes'
-
-# === while False with else (else runs immediately) ===
-flag = 0
-while False:
-    flag = 1
-else:
-    flag = 2
-assert flag == 2, 'while False runs else immediately'
-
-# === Nested while loops ===
-i = 0
-result = []
-while i < 2:
-    j = 0
-    while j < 2:
-        result.append((i, j))
-        j += 1
-    i += 1
-assert result == [(0, 0), (0, 1), (1, 0), (1, 1)], 'nested while loops'
-
-# === Nested while with break inner ===
-i = 0
-result = []
-while i < 3:
-    j = 0
-    while j < 3:
-        if j == 1:
-            break
-        result.append((i, j))
-        j += 1
-    i += 1
-assert result == [(0, 0), (1, 0), (2, 0)], 'nested while break inner only'
-
-# === For inside while ===
-i = 0
-result = []
-while i < 2:
-    for j in ['a', 'b']:
-        result.append((i, j))
-    i += 1
-assert result == [(0, 'a'), (0, 'b'), (1, 'a'), (1, 'b')], 'for inside while'
-
-# === While inside for ===
-result = []
-for i in [0, 1]:
-    j = 0
-    while j < 2:
-        result.append((i, j))
-        j += 1
-assert result == [(0, 0), (0, 1), (1, 0), (1, 1)], 'while inside for'
-
-# === Complex condition with and ===
-i = 0
-j = 10
-result = []
-while i < 5 and j > 5:
-    result.append((i, j))
-    i += 1
-    j -= 1
-assert result == [(0, 10), (1, 9), (2, 8), (3, 7), (4, 6)], 'while with and condition'
-
-# === Complex condition with or ===
-i = 5
-count = 0
-while i < 3 or count < 2:
-    count += 1
-    i += 1
-assert count == 2, 'while with or condition'
-
-
-# === While with function call condition ===
-def check(n):
-    return n < 3
-
-
-i = 0
-result = []
-while check(i):
-    result.append(i)
-    i += 1
-assert result == [0, 1, 2], 'while with function call condition'
-
-# === Continue does not skip else ===
-i = 0
-flag = 0
-while i < 3:
-    i += 1
-    if i == 2:
-        continue
-else:
-    flag = 1
-assert flag == 1, 'continue does not skip else'
-
-# === Nested while - break outer via flag ===
-i = 0
-result = []
-done = False
-while i < 3 and not done:
-    j = 0
-    while j < 3:
-        if i == 1 and j == 1:
-            done = True
-            break
-        result.append((i, j))
-        j += 1
-    i += 1
-assert result == [(0, 0), (0, 1), (0, 2), (1, 0)], 'nested while with flag break'
-
-# === While with negative condition ===
-i = 5
-result = []
-while not i == 3:
-    result.append(i)
-    i -= 1
-assert result == [5, 4], 'while with not condition'
-
-# === Nested while with inner else ===
-i = 0
-result = []
-while i < 2:
-    j = 0
-    while j < 2:
-        result.append(j)
-        j += 1
-    else:
-        result.append('inner-else')
-    i += 1
-assert result == [0, 1, 'inner-else', 0, 1, 'inner-else'], 'nested while with inner else'
-
-# === Break in nested while skips inner else ===
-i = 0
-result = []
-while i < 2:
-    j = 0
-    while j < 3:
-        if j == 1:
-            break
-        result.append(j)
-        j += 1
-    else:
-        result.append('inner-else')
-    i += 1
-assert result == [0, 0], 'break skips inner else only'