superacli 1.1.5 → 1.1.7

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

@@ -1,47 +0,0 @@
-# === Basic functions ===
-def simple(a, b, c):
-    return a + b + c
-
-
-assert simple(1, 2, 3) == 6, 'simple function'
-assert simple(10, 20, 30) == 60, 'simple function with larger values'
-
-
-# === Positional-only parameters ===
-def pos_only(a, b, /, c):
-    return a + b + c
-
-
-assert pos_only(1, 2, 3) == 6, 'positional-only params'
-assert pos_only(5, 5, 5) == 15, 'positional-only all same'
-assert pos_only(5, 5, c=5) == 15, 'positional-only all same'
-
-
-# === All positional-only ===
-def all_pos_only(a, b, c, /):
-    return a + b + c
-
-
-assert all_pos_only(1, 2, 3) == 6, 'all positional-only'
-
-
-# === Multiple parameter groups ===
-def multi_group(a, /, b, c):
-    return f'a={a} b={b} c={c}'
-
-
-assert multi_group(1, 2, 3) == 'a=1 b=2 c=3', 'mixed positional-only and regular'
-assert multi_group(1, b=2, c=3) == 'a=1 b=2 c=3', 'mixed positional-only and regular'
-assert multi_group(1, c=3, b=2) == 'a=1 b=2 c=3', 'mixed positional-only and regular'
-
-
-# === Call-site *args unpacking ===
-def collect_all(*values):
-    return values
-
-
-source_tuple = (1, 2, 3)
-assert collect_all(*source_tuple) == (1, 2, 3), 'tuple unpacked with *args'
-
-source_list = [4, 5]
-assert collect_all(0, *source_list) == (0, 4, 5), 'positional args followed by *args'

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

@@ -1,6 +0,0 @@
-def f(a, b, c):
-    return a + b + c
-
-
-f()
-# Raise=TypeError("f() missing 3 required positional arguments: 'a', 'b', and 'c'")

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

@@ -1,6 +0,0 @@
-def f(x):
-    return x
-
-
-f()
-# Raise=TypeError("f() missing 1 required positional argument: 'x'")

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

@@ -1,6 +0,0 @@
-def f(a, b):
-    return a + b
-
-
-f(1)
-# Raise=TypeError("f() missing 1 required positional argument: 'b'")

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

@@ -1,6 +0,0 @@
-def f(x):
-    return x
-
-
-f(1, 2)
-# Raise=TypeError('f() takes 1 positional argument but 2 were given')

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

@@ -1,6 +0,0 @@
-def f(a, b):
-    return a + b
-
-
-f(1, 2, 3)
-# Raise=TypeError('f() takes 2 positional arguments but 3 were given')

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

@@ -1,6 +0,0 @@
-def f():
-    return 1
-
-
-f(42)
-# Raise=TypeError('f() takes 0 positional arguments but 1 was given')

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

@@ -1,7 +0,0 @@
-def f():
-    x = 1
-    global x  # type: ignore[reportAssignmentBeforeGlobalDeclaration]
-
-
-f()
-# Raise=SyntaxError("name 'x' is assigned to before global declaration")

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

@@ -1,163 +0,0 @@
-# === Basic global read/write ===
-x1 = 42
-
-
-def read_explicit():
-    global x1
-    return x1
-
-
-assert read_explicit() == 42, 'explicit global read'
-
-
-x2 = 1
-
-
-def write_explicit():
-    global x2
-    x2 = 2
-
-
-write_explicit()
-assert x2 == 2, 'explicit global write'
-
-
-x3 = 42
-
-
-def read_implicit():
-    return x3  # no local x3, reads global
-
-
-assert read_implicit() == 42, 'implicit global read'
-
-
-# === Multiple functions sharing global ===
-counter1 = 0
-
-
-def inc():
-    global counter1
-    counter1 = counter1 + 1
-
-
-def get_counter():
-    return counter1
-
-
-inc()
-inc()
-assert get_counter() == 2, 'multiple functions sharing global'
-
-
-# === Mutating global containers (no 'global' needed) ===
-data1 = {'a': 1}
-
-
-def add_dict_entry():
-    data1['b'] = 2
-
-
-add_dict_entry()
-assert data1 == {'a': 1, 'b': 2}, 'mutate global dict'
-
-
-items1 = [1, 2]
-
-
-def append_list_item():
-    items1.append(3)
-
-
-append_list_item()
-assert items1 == [1, 2, 3], 'mutate global list append'
-
-
-items2 = ['a', 'c']
-
-
-def insert_list_item():
-    items2.insert(1, 'b')
-
-
-insert_list_item()
-assert items2 == ['a', 'b', 'c'], 'mutate global list insert'
-
-
-items3 = []
-
-
-def build_list():
-    items3.append(1)
-    items3.append(2)
-    items3.append(3)
-
-
-build_list()
-assert items3 == [1, 2, 3], 'mutate global list multiple'
-
-
-# === Reassigning global containers (requires 'global') ===
-items4 = [1, 2]
-
-
-def replace_list():
-    global items4
-    items4 = [3, 4, 5]
-
-
-replace_list()
-assert items4 == [3, 4, 5], 'reassign global list'
-
-
-# === Nested functions with global ===
-x4 = 1
-
-
-def outer_global():
-    def inner():
-        global x4
-        x4 = 10
-
-    inner()
-
-
-outer_global()
-assert x4 == 10, 'nested inner global write'
-
-
-x5 = 42
-
-
-def outer_read():
-    def inner():
-        return x5  # reads global
-
-    return inner()
-
-
-assert outer_read() == 42, 'nested inner global read'
-
-
-# === Shadowing ===
-x6 = 10
-
-
-def shadow_local():
-    x6 = 20  # creates local (shadows global)
-    return x6
-
-
-assert shadow_local() == 20, 'local shadows global'
-
-
-x7 = 10
-
-
-def shadow_unchanged():
-    x7 = 99  # local
-    return x7
-
-
-assert shadow_unchanged() == 99, 'shadowing returns local'
-assert x7 == 10, 'global unchanged after shadowing'

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

@@ -1,2 +0,0 @@
-hash({})
-# Raise=TypeError("unhashable type: 'dict'")

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

@@ -1,2 +0,0 @@
-hash([1, 2, 3])
-# Raise=TypeError("unhashable type: 'list'")

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

@@ -1,153 +0,0 @@
-# === Hash returns int type ===
-assert isinstance(hash(42), int), 'hash returns int type'
-assert isinstance(hash('hello'), int), 'hash of str returns int'
-assert isinstance(hash((1, 2, 3)), int), 'hash of tuple returns int'
-assert isinstance(hash(3.14), int), 'hash of float returns int'
-
-# === Hash consistency for same values ===
-assert hash(42) == hash(42), 'int hash consistent'
-assert hash(-1) == hash(-1), 'negative int hash consistent'
-assert hash(0) == hash(0), 'zero hash consistent'
-assert hash('hello') == hash('hello'), 'str hash consistent'
-assert hash('') == hash(''), 'empty str hash consistent'
-assert hash(b'hello') == hash(b'hello'), 'bytes hash consistent'
-assert hash(b'') == hash(b''), 'empty bytes hash consistent'
-assert hash(None) == hash(None), 'None hash consistent'
-assert hash(True) == hash(True), 'True hash consistent'
-assert hash(False) == hash(False), 'False hash consistent'
-assert hash((1, 2, 3)) == hash((1, 2, 3)), 'tuple hash consistent'
-assert hash(()) == hash(()), 'empty tuple hash consistent'
-assert hash((1,)) == hash((1,)), 'single element tuple hash consistent'
-assert hash(3.14) == hash(3.14), 'float hash consistent'
-assert hash(0.0) == hash(0.0), 'zero float hash consistent'
-assert hash(-0.0) == hash(-0.0), 'negative zero float hash consistent'
-assert hash(...) == hash(...), 'ellipsis hash consistent'
-
-# === Range hash consistency ===
-assert hash(range(10)) == hash(range(10)), 'range hash consistent'
-assert hash(range(0)) == hash(range(0)), 'empty range hash consistent'
-assert hash(range(1, 10)) == hash(range(1, 10)), 'range with start hash consistent'
-assert hash(range(1, 10, 2)) == hash(range(1, 10, 2)), 'range with step hash consistent'
-assert hash(range(-5, 5)) == hash(range(-5, 5)), 'negative start range hash consistent'
-
-# === Different range values should hash differently ===
-assert hash(range(10)) != hash(range(11)), 'different range stop hashes differently'
-assert hash(range(10)) != hash(range(1, 10)), 'range with different start hashes differently'
-assert hash(range(10)) != hash(range(0, 10, 2)), 'range with step hashes differently'
-assert hash(range(1, 10, 2)) != hash(range(1, 10, 3)), 'different steps hash differently'
-
-# === Different values should hash differently ===
-assert hash(1) != hash(2), 'different ints hash differently'
-assert hash('a') != hash('b'), 'different strs hash differently'
-assert hash(b'a') != hash(b'b'), 'different bytes hash differently'
-assert hash((1, 2)) != hash((1, 3)), 'different tuples hash differently'
-assert hash((1, 2)) != hash((2, 1)), 'tuple order matters for hash'
-assert hash(True) != hash(False), 'True and False hash differently'
-assert hash(3.14) != hash(2.71), 'different floats hash differently'
-
-# === Type differentiation for clearly different types ===
-assert hash(()) != hash(''), 'empty tuple and empty str hash differently'
-assert hash('1') != hash(1), 'str "1" and int 1 hash differently'
-assert hash(b'1') != hash(1), 'bytes b"1" and int 1 hash differently'
-
-# === Nested tuple hashing ===
-assert hash((1, (2, 3))) == hash((1, (2, 3))), 'nested tuple hash consistent'
-assert hash((1, (2, 3))) != hash((1, (2, 4))), 'nested tuples with different inner values hash differently'
-assert hash(((1, 2), (3, 4))) == hash(((1, 2), (3, 4))), 'tuple of tuples hash consistent'
-
-# === String/bytes content equality across representations ===
-# Interned strings and heap strings with same content should hash the same
-s1 = 'test'
-s2 = 'te' + 'st'
-assert hash(s1) == hash(s2), 'concatenated string hashes same as literal'
-
-b1 = b'test'
-b2 = b'te' + b'st'
-assert hash(b1) == hash(b2), 'concatenated bytes hashes same as literal'
-
-
-# === Function hashing ===
-def f():
-    pass
-
-
-def g():
-    pass
-
-
-assert hash(f) == hash(f), 'function hash consistent'
-assert hash(g) == hash(g), 'different function hash consistent'
-assert hash(f) != hash(g), 'different functions hash differently'
-
-# === Builtin function hashing ===
-assert hash(len) == hash(len), 'builtin hash consistent'
-assert hash(print) == hash(print), 'print builtin hash consistent'
-assert hash(len) != hash(print), 'different builtins hash differently'
-
-# === Builtin type hashing ===
-assert hash(int) == hash(int), 'int type hash consistent'
-assert hash(str) == hash(str), 'str type hash consistent'
-assert hash(int) != hash(str), 'different types hash differently'
-assert hash(int) != hash(float), 'int and float types hash differently'
-
-# === Exception type hashing ===
-assert hash(ValueError) == hash(ValueError), 'exception type hash consistent'
-assert hash(TypeError) == hash(TypeError), 'TypeError hash consistent'
-assert hash(ValueError) != hash(TypeError), 'different exception types hash differently'
-
-# === Dict key behavior with hashes ===
-# Verify that hash consistency works with dict lookups
-d = {}
-d[42] = 'int'
-d['hello'] = 'str'
-d[(1, 2)] = 'tuple'
-d[range(5)] = 'range'
-d[3.14] = 'float'
-d[None] = 'none'
-
-assert d[42] == 'int', 'int dict key works'
-assert d['hello'] == 'str', 'str dict key works'
-assert d[(1, 2)] == 'tuple', 'tuple dict key works'
-assert d[range(5)] == 'range', 'range dict key works'
-assert d[3.14] == 'float', 'float dict key works'
-assert d[None] == 'none', 'None dict key works'
-
-# === Multiple ranges as dict keys ===
-rd = {}
-rd[range(5)] = 'a'
-rd[range(10)] = 'b'
-rd[range(1, 5)] = 'c'
-rd[range(0, 5, 2)] = 'd'
-
-assert rd[range(5)] == 'a', 'range(5) key retrieval'
-assert rd[range(10)] == 'b', 'range(10) key retrieval'
-assert rd[range(1, 5)] == 'c', 'range(1,5) key retrieval'
-assert rd[range(0, 5, 2)] == 'd', 'range with step key retrieval'
-assert len(rd) == 4, 'all ranges stored as distinct keys'
-
-
-# === Functions as dict keys ===
-def key_fn():
-    pass
-
-
-fd = {}
-fd[key_fn] = 'func_value'
-assert fd[key_fn] == 'func_value', 'function as dict key works'
-
-# === Builtins as dict keys ===
-bd = {}
-bd[len] = 'len_value'
-bd[print] = 'print_value'
-assert bd[len] == 'len_value', 'builtin len as dict key'
-assert bd[print] == 'print_value', 'builtin print as dict key'
-assert len(bd) == 2, 'different builtins are distinct keys'
-
-# === Types as dict keys ===
-td = {}
-td[int] = 'int_type'
-td[str] = 'str_type'
-td[ValueError] = 'value_error'
-assert td[int] == 'int_type', 'int type as dict key'
-assert td[str] == 'str_type', 'str type as dict key'
-assert td[ValueError] == 'value_error', 'exception type as dict key'

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

@@ -1,3 +0,0 @@
-# xfail=cpython
-id(b'test') == id(b'test')
-# Return=False

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

@@ -1,5 +0,0 @@
-# value-based identity: same value = same id
-x = 100
-y = x
-id(x) == id(y)
-# Return=True

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

@@ -1,3 +0,0 @@
-# value-based identity: same value = same identity
-1 is 1
-# Return=True

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

@@ -1,10 +0,0 @@
-# xfail=cpython
-# === Heap types may have the same id if lifetimes do not overlap ===
-# See https://docs.python.org/3/library/functions.html#id
-# for Cpython it happens to be the case that for different types they end
-# up being allocated in different memory locations, but this is not guaranteed by the language spec
-assert id([]) == id([]), 'empty list may have same id'
-assert id([]) == id({}), 'empty list may have same id as empty dict'
-assert id([]) == id((1,)), 'empty list may have same id as tuple'
-assert id((1, 2)) == id((1, 2)), 'non-empty tuple may have same id'
-assert id([1, 2]) == id([1, 2]), 'non-empty list may have same id'

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

@@ -1,6 +0,0 @@
-# === Heap types may have the same id if lifetimes do not overlap ===
-# See https://docs.python.org/3/library/functions.html#id
-assert id([]) == id([]), 'empty list may have same id'
-assert id({}) == id({}), 'empty dict may have same id'
-assert id((1, 2)) == id((1, 2)), 'non-empty tuple may have same id'
-assert id([1, 2]) == id([1, 2]), 'non-empty list may have same id'

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

@@ -1,97 +0,0 @@
-# === id() returns int type ===
-assert isinstance(id(None), int), 'id returns int type'
-assert isinstance(id([]), int), 'id of list returns int'
-assert isinstance(id('hello'), int), 'id of str returns int'
-assert isinstance(id(42), int), 'id of int returns int'
-
-# === Identity operator (is) ===
-assert (True is True) == True, 'is True'
-assert (False is False) == True, 'is False'
-assert (None is None) == True, 'is None'
-assert (... is ...) == True, 'is Ellipsis'
-
-# === Identity operator (is not) ===
-assert (True is not True) == False, 'is not True'
-assert (True is not False) == True, 'is not False'
-
-# === Singleton identity ===
-assert id(None) == id(None), 'None singleton'
-assert id(True) == id(True), 'True singleton'
-assert id(False) == id(False), 'False singleton'
-assert id(...) == id(...), 'Ellipsis singleton'
-
-# bool and int are distinct
-assert id(True) != id(1), 'True is not 1'
-assert id(False) != id(0), 'False is not 0'
-
-# distinct singletons
-assert id(None) != id(True), 'None is not True'
-assert id(None) != id(False), 'None is not False'
-assert id(None) != id(...), 'None is not Ellipsis'
-
-# === Integer identity ===
-assert id(10) != id(20), 'different ints distinct'
-
-# === Float identity ===
-assert id(1.0) != id(2.0), 'different floats distinct'
-
-# === List assignment shares identity ===
-lst = [1, 2]
-ref = lst
-assert id(lst) == id(ref), 'list assignment shared'
-assert lst is ref, 'list is same'
-
-# === Variable identity is stable ===
-lst = [1, 2]
-assert id(lst) == id(lst), 'var id stable'
-
-# === List mutation preserves identity ===
-a = [1, 2]
-b = a
-b.append(3)
-assert a is b, 'list mutate preserves identity'
-
-# === Mixed types have distinct ids ===
-assert id(1) != id('1'), 'int vs str distinct'
-
-# === Tuple singleton is guaranteed to have a unique id ===
-assert id([]) != id(()), 'list vs tuple singleton distinct'
-assert id({}) != id(()), 'dict vs tuple singleton distinct'
-assert id(1) != id(()), 'int vs tuple singleton distinct'
-
-# === Multiple refs share id ===
-x = [1, 2]
-y = x
-z = y
-assert id(x) == id(y), 'multiple refs share id xy'
-assert id(y) == id(z), 'multiple refs share id yz'
-
-# === String assignment shares identity ===
-s = 'hello'
-r = s
-assert id(s) == id(r), 'str assignment shared'
-
-# === Bytes assignment shares identity ===
-b = b'hello'
-r = b
-assert id(b) == id(r), 'bytes assignment shared'
-
-# === Tuple assignment shares identity ===
-t = (1, 2)
-r = t
-assert id(t) == id(r), 'tuple assignment shared'
-
-# === Boolean is tests ===
-assert (True is True) == True, 'bool is test'
-assert (False is False) == True, 'bool is test 2'
-
-# === Array is test ===
-a = [1, 2]
-b = a
-assert (a is b) == True, 'array is test'
-assert (a is [1, 2]) == False, 'array is new literal'
-
-# === None is tests ===
-x = None
-assert (x is None) == True, 'var is None'
-assert (1 is None) == False, 'int is not None'

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

@@ -1,3 +0,0 @@
-# With string interning, identical literals have the same id
-id('hello') == id('hello')
-# Return=True