superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,238 @@
+# call-external
+# === Basic dataclass tests ===
+
+# Get immutable dataclass from external function
+point = make_point()
+
+# === repr and str ===
+assert repr(point) == 'Point(x=1, y=2)', f'point repr {point=!r}'
+assert str(point) == 'Point(x=1, y=2)', 'point str'
+
+# === Boolean truthiness ===
+# Dataclasses are always truthy (like Python class instances)
+assert bool(point), 'dataclass bool is True'
+
+# === Hash for immutable dataclass ===
+# Immutable (frozen) dataclasses are hashable
+h1 = hash(point)
+assert h1 != 0, 'hash is not zero'
+
+# Hash is consistent - same object hashes to same value
+h2 = hash(point)
+assert h1 == h2, 'hash is consistent'
+
+# Equal frozen dataclasses hash to same value
+point2 = make_point()
+assert hash(point) == hash(point2), 'equal dataclasses have equal hash'
+
+# Frozen dataclass can be used as dict key
+d = {point: 'first'}
+assert d[point] == 'first', 'frozen dataclass as dict key'
+assert d[point2] == 'first', 'equal frozen dataclass looks up same value'
+
+# Frozen dataclass can be added to set
+s = {point, point2}
+assert len(s) == 1, 'equal frozen dataclasses deduplicated in set'
+
+# Different field values produce different hash
+alice = make_user('Alice')
+bob = make_user('Bob')
+assert hash(alice) != hash(bob), 'different field values have different hash'
+
+# === Mutable dataclass ===
+mut_point = make_mutable_point()
+assert repr(mut_point) == 'MutablePoint(x=1, y=2)', f'mutable point repr {mut_point=!r}'
+
+# === Dataclass with string argument ===
+alice = make_user('Alice')
+assert repr(alice) == "User(name='Alice', active=True)", f'user repr with string field {alice=!r}'
+
+# === Dataclass in list (using existing variables) ===
+points = [point, mut_point, alice]
+assert len(points) == 3, 'dataclass list length'
+
+# === Attribute access (get) ===
+# Access fields on immutable dataclass
+assert point.x == 1, 'point.x is 1'
+assert point.y == 2, 'point.y is 2'
+
+# Access fields on mutable dataclass
+assert mut_point.x == 1, 'mut_point.x is 1'
+assert mut_point.y == 2, 'mut_point.y is 2'
+
+# Access fields on dataclass with string field
+assert alice.name == 'Alice', 'alice.name is Alice'
+assert alice.active == True, 'alice.active is True'
+
+# === Attribute assignment (set) ===
+# Modify mutable dataclass
+mut_point.x = 10
+assert mut_point.x == 10, 'mut_point.x updated to 10'
+mut_point.y = 20
+assert mut_point.y == 20, 'mut_point.y updated to 20'
+assert repr(mut_point) == 'MutablePoint(x=10, y=20)', f'repr after attribute update {mut_point=!r}'
+
+# === set other attributes
+mut_point.z = 30
+assert mut_point.z == 30, 'mut_point.z updated to 30'
+assert repr(mut_point) == 'MutablePoint(x=10, y=20)', 'repr after attribute update'
+
+# === Nested attribute access (chained get) ===
+# Create outer dataclass with inner dataclass as field
+outer = make_mutable_point()
+inner = make_mutable_point()
+inner.x = 100
+inner.y = 200
+outer.x = inner
+
+# Chained attribute get: outer.x.y
+assert outer.x.x == 100, 'outer.x.x is 100'
+assert outer.x.y == 200, 'outer.x.y is 200'
+
+# === Nested attribute assignment (chained set) ===
+# Modify nested field via chained access
+outer.x.x = 999
+assert outer.x.x == 999, 'outer.x.x updated to 999'
+outer.x.y = 888
+assert outer.x.y == 888, 'outer.x.y updated to 888'
+
+# Verify inner was modified (same object)
+assert inner.x == 999, 'inner.x also updated to 999'
+assert inner.y == 888, 'inner.y also updated to 888'
+
+# === Deeper nesting (3 levels) ===
+level1 = make_mutable_point()
+level2 = make_mutable_point()
+level3 = make_mutable_point()
+level3.x = 42
+level2.x = level3
+level1.x = level2
+
+# 3-level chained get
+assert level1.x.x.x == 42, 'level1.x.x.x is 42'
+
+# 3-level chained set
+level1.x.x.x = 7
+assert level1.x.x.x == 7, 'level1.x.x.x updated to 7'
+assert level3.x == 7, 'level3.x also updated to 7'
+
+# === Empty dataclass ===
+empty = make_empty()
+assert repr(empty) == 'Empty()', 'empty dataclass repr'
+assert str(empty) == 'Empty()', 'empty dataclass str'
+
+# === FrozenInstanceError is subclass of AttributeError ===
+# Catching AttributeError should also catch FrozenInstanceError
+frozen_point = make_point()
+caught = False
+try:
+    frozen_point.x = 10
+except AttributeError:
+    caught = True
+assert caught, 'FrozenInstanceError caught by AttributeError'
+
+# === Error: accessing non-existent attribute ===
+try:
+    point.nonexistent
+    assert False, 'should have raised AttributeError for missing attr'
+except AttributeError as e:
+    assert str(e) == "'Point' object has no attribute 'nonexistent'", f'wrong message: {e}'
+
+# === Error: accessing non-existent private attribute ===
+try:
+    point._private
+    assert False, 'should have raised AttributeError for private attr'
+except AttributeError as e:
+    assert str(e) == "'Point' object has no attribute '_private'", f'wrong message: {e}'
+
+# === Error: calling a dunder that doesn't exist ===
+try:
+    point.__nonexistent__()
+    assert False, 'should have raised AttributeError for dunder'
+except AttributeError as e:
+    assert str(e) == "'Point' object has no attribute '__nonexistent__'", f'wrong message: {e}'
+
+# === Error: calling a private method that doesn't exist ===
+try:
+    point._private_method()
+    assert False, 'should have raised AttributeError for private method'
+except AttributeError as e:
+    assert str(e) == "'Point' object has no attribute '_private_method'", f'wrong message: {e}'
+
+# === Error: calling a field value (not callable) ===
+try:
+    point.x()
+    assert False, 'should have raised TypeError for calling int field'
+except TypeError as e:
+    assert str(e) == "'int' object is not callable", f'wrong message: {e}'
+
+# === Error: calling a non-existent public method ===
+try:
+    point.nonexistent_method()
+    assert False, 'should have raised AttributeError for missing method'
+except AttributeError as e:
+    assert str(e) == "'Point' object has no attribute 'nonexistent_method'", f'wrong message: {e}'
+
+# === Error: same errors on mutable dataclass ===
+try:
+    mut_point.nonexistent
+    assert False, 'should have raised AttributeError on mutable dc'
+except AttributeError as e:
+    assert str(e) == "'MutablePoint' object has no attribute 'nonexistent'", f'wrong message: {e}'
+
+try:
+    mut_point.x()
+    assert False, 'should have raised TypeError on mutable dc field call'
+except TypeError as e:
+    assert str(e) == "'int' object is not callable", f'wrong message: {e}'
+
+# === Method calls: no args (exercises ArgValues::prepend on Empty) ===
+result = point.sum()
+assert result == 3, f'Point.sum() should be 3, got {result}'
+
+# === Method calls: two positional args (exercises ArgValues::prepend on Two) ===
+new_point = point.add(10, 20)
+assert new_point.x == 11, f'Point.add x should be 11, got {new_point.x}'
+assert new_point.y == 22, f'Point.add y should be 22, got {new_point.y}'
+
+# === Method calls: one positional arg (exercises ArgValues::prepend on One) ===
+scaled = point.scale(3)
+assert scaled.x == 3, f'Point.scale x should be 3, got {scaled.x}'
+assert scaled.y == 6, f'Point.scale y should be 6, got {scaled.y}'
+
+# === Method calls: returning a string ===
+desc = point.describe('pt')
+assert desc == 'pt(1, 2)', f'Point.describe should be pt(1, 2), got {desc}'
+
+# === Method calls on mutable dataclass ===
+mut_p2 = make_mutable_point()
+mut_sum = mut_p2.sum()
+assert mut_sum == 3, f'MutablePoint.sum() should be 3, got {mut_sum}'
+
+# === Method calls on User dataclass (string field) ===
+alice2 = make_user('Alice')
+greeting = alice2.greeting()
+assert greeting == 'Hello, Alice!', f'User.greeting should be Hello, Alice!, got {greeting}'
+
+# === Method call returning dataclass - chained access ===
+p3 = point.add(0, 0)
+assert p3.x == 1, f'chained method access: p3.x should be 1, got {p3.x}'
+assert p3.y == 2, f'chained method access: p3.y should be 2, got {p3.y}'
+
+# === Method calls with keyword-only args (exercises ArgValues::prepend on Kwargs) ===
+desc_kw = point.describe(label='custom')
+assert desc_kw == 'custom(1, 2)', f'Point.describe(label=) should be custom(1, 2), got {desc_kw}'
+
+# === Error: calling non-existent method on mutable dataclass ===
+try:
+    mut_p2.nonexistent_method()
+    assert False, 'should have raised AttributeError for missing method on mutable dc'
+except AttributeError as e:
+    assert str(e) == "'MutablePoint' object has no attribute 'nonexistent_method'", f'wrong message: {e}'
+
+# === Error: calling non-existent method on User ===
+try:
+    alice2.missing()
+    assert False, 'should have raised AttributeError for missing method on User'
+except AttributeError as e:
+    assert str(e) == "'User' object has no attribute 'missing'", f'wrong message: {e}'

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

@@ -0,0 +1,12 @@
+# call-external
+# Test that calling a field value (not a method) raises TypeError
+point = make_point()
+point.x()
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "dataclass__call_field_error.py", line 4, in <module>
+    point.x()
+    ~~~~~~~~~
+TypeError: 'int' object is not callable
+"""

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

@@ -0,0 +1,12 @@
+# call-external
+# Test that assigning to a frozen dataclass raises FrozenInstanceError
+point = make_point()
+point.x = 10
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "dataclass__frozen_set_error.py", line 4, in <module>
+    point.x = 10
+    ~~~~~~~
+FrozenInstanceError: cannot assign to field 'x'
+"""

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

@@ -0,0 +1,11 @@
+# call-external
+# Test that accessing a non-existent attribute on a dataclass raises AttributeError
+point = make_point()
+point.z
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "dataclass__get_missing_attr_error.py", line 4, in <module>
+    point.z
+AttributeError: 'Point' object has no attribute 'z'
+"""

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

@@ -0,0 +1,3 @@
+d = {}
+d.get([], 'fallback')
+# Raise=TypeError("cannot use 'list' as a dict key (unhashable type: 'list')")

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

@@ -0,0 +1,2 @@
+{'a': 1, []: 2}
+# Raise=TypeError("cannot use 'list' as a dict key (unhashable type: 'list')")

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

@@ -0,0 +1,3 @@
+d = {'a': 1}
+d.pop('missing')
+# Raise=KeyError('missing')

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

@@ -0,0 +1,151 @@
+# === dict.clear() ===
+d = {'a': 1, 'b': 2}
+d.clear()
+assert d == {}, 'clear empties the dict'
+
+d = {}
+d.clear()
+assert d == {}, 'clear on empty dict is no-op'
+
+# === dict.copy() ===
+d = {'a': 1, 'b': 2}
+copy = d.copy()
+assert copy == {'a': 1, 'b': 2}, 'copy creates equal dict'
+assert copy is not d, 'copy creates new dict object'
+d['c'] = 3
+assert 'c' not in copy, 'copy is independent'
+
+d = {}
+copy = d.copy()
+assert copy == {}, 'copy empty dict'
+
+# === dict.update() ===
+d = {'a': 1}
+d.update({'b': 2})
+assert d == {'a': 1, 'b': 2}, 'update with dict'
+
+d = {'a': 1}
+d.update({'a': 10})
+assert d == {'a': 10}, 'update overwrites existing key'
+
+d = {'a': 1}
+d.update()
+assert d == {'a': 1}, 'update with no args is no-op'
+
+d = {}
+d.update([('a', 1), ('b', 2)])
+assert d == {'a': 1, 'b': 2}, 'update with list of tuples'
+
+# === dict.setdefault() ===
+d = {'a': 1}
+result = d.setdefault('a', 10)
+assert result == 1, 'setdefault returns existing value'
+assert d == {'a': 1}, 'setdefault does not overwrite'
+
+d = {'a': 1}
+result = d.setdefault('b', 2)
+assert result == 2, 'setdefault returns default for new key'
+assert d == {'a': 1, 'b': 2}, 'setdefault inserts new key'
+
+d = {'a': 1}
+result = d.setdefault('b')
+assert result is None, 'setdefault default is None'
+assert d == {'a': 1, 'b': None}, 'setdefault inserts None'
+
+# === dict.popitem() ===
+d = {'a': 1, 'b': 2}
+item = d.popitem()
+assert item == ('b', 2), 'popitem returns last inserted item'
+assert d == {'a': 1}, 'popitem removes item'
+
+d = {'x': 10}
+item = d.popitem()
+assert item == ('x', 10), 'popitem on single-item dict'
+assert d == {}, 'dict is now empty'
+
+# === dict.fromkeys() ===
+d = dict.fromkeys(['a', 'b', 'c'])
+assert d == {'a': None, 'b': None, 'c': None}, 'fromkeys with list, default None'
+
+d = dict.fromkeys(['a', 'b'], 0)
+assert d == {'a': 0, 'b': 0}, 'fromkeys with default value'
+
+d = dict.fromkeys([])
+assert d == {}, 'fromkeys with empty iterable'
+
+d = dict.fromkeys('abc')
+assert d == {'a': None, 'b': None, 'c': None}, 'fromkeys with string iterable'
+
+d = dict.fromkeys(range(3), 'x')
+assert d == {0: 'x', 1: 'x', 2: 'x'}, 'fromkeys with range iterable'
+
+d = dict.fromkeys((1, 2, 3), [])
+assert d[1] is d[2] and d[2] is d[3], 'fromkeys shares same value object for all keys'
+
+# Duplicate keys - later occurrence wins
+d = dict.fromkeys(['a', 'b', 'a'], 1)
+assert d == {'a': 1, 'b': 1}, 'fromkeys with duplicate keys'
+assert list(d.keys()) == ['a', 'b'], 'fromkeys preserves first occurrence order'
+
+# === dict.fromkeys() instance access ===
+# fromkeys is a classmethod but should also work on instances
+d = {}.fromkeys(['a', 'b'])
+assert d == {'a': None, 'b': None}, 'fromkeys on empty dict instance'
+
+d = {'x': 1}.fromkeys(['a', 'b'], 0)
+assert d == {'a': 0, 'b': 0}, 'fromkeys on non-empty dict instance (ignores original)'
+
+# === dict.update() with keyword arguments ===
+d = {'a': 1}
+d.update(b=2)
+assert d == {'a': 1, 'b': 2}, 'update with single kwarg'
+
+d = {'a': 1}
+d.update(b=2, c=3)
+assert d == {'a': 1, 'b': 2, 'c': 3}, 'update with multiple kwargs'
+
+d = {'a': 1}
+d.update(a=10)
+assert d == {'a': 10}, 'update kwarg overwrites existing key'
+
+d = {}
+d.update(a=1, b=2)
+assert d == {'a': 1, 'b': 2}, 'update empty dict with kwargs'
+
+# update with both positional dict and kwargs
+d = {'a': 1}
+d.update({'b': 2}, c=3)
+assert d == {'a': 1, 'b': 2, 'c': 3}, 'update with dict and kwargs'
+
+# kwargs overwrite positional dict values
+d = {'a': 1}
+d.update({'b': 2}, b=20)
+assert d == {'a': 1, 'b': 20}, 'update kwargs overwrite positional dict'
+
+# update with iterable and kwargs
+d = {}
+d.update([('a', 1)], b=2)
+assert d == {'a': 1, 'b': 2}, 'update with iterable and kwargs'
+
+# === Error message for unknown classmethod ===
+# Error message should say 'dict' not 'type'
+try:
+    dict.nonexistent()
+    assert False, 'should raise AttributeError'
+except AttributeError as e:
+    msg = str(e)
+    assert 'dict' in msg, f'error should mention dict, got: {e}'
+    assert 'nonexistent' in msg, f'error should mention method name, got: {e}'
+
+# === dict.update() sequence element error ===
+# Invalid sequence elements should raise ValueError
+try:
+    d = {}
+    d.update([('a', 1), 'x', ('c', 3)])  # 'x' at index 1 is not a 2-tuple
+    assert False, 'should raise ValueError'
+except (ValueError, TypeError) as e:
+    msg = str(e)
+    # Error message should mention 'length' requirement
+    assert 'length' in msg.lower(), f'error should mention length, got: {e}'
+    # TODO: CPython includes element index (#N) in error message
+    # assert '#1' in msg, 'error should mention element index'

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

@@ -0,0 +1,133 @@
+# === Dict literals ===
+assert {} == {}, 'empty literal'
+assert {'a': 1} == {'a': 1}, 'single item literal'
+assert {'a': 1, 'b': 2} == {'a': 1, 'b': 2}, 'multiple items literal'
+assert {1: 'a', 2: 'b'} == {1: 'a', 2: 'b'}, 'int keys literal'
+
+# === Dict length ===
+assert len({}) == 0, 'len empty'
+assert len({'a': 1, 'b': 2, 'c': 3}) == 3, 'len multiple'
+
+# === Dict equality ===
+assert ({'a': 1, 'b': 2} == {'b': 2, 'a': 1}) == True, 'equality true (order independent)'
+assert ({'a': 1} == {'a': 2}) == False, 'equality false'
+
+# === Dict subscript get ===
+d = {'name': 'Alice', 'age': 30}
+assert d['name'] == 'Alice', 'subscript get str key'
+assert d['age'] == 30, 'subscript get value'
+
+d = {1: 'one', 2: 'two'}
+assert d[1] == 'one', 'subscript get int key'
+
+# === Dict subscript set ===
+d = {'a': 1}
+d['b'] = 2
+assert d == {'a': 1, 'b': 2}, 'subscript set new key'
+
+d = {'a': 1}
+d['a'] = 99
+assert d == {'a': 99}, 'subscript set existing key'
+
+# === Dict subscript augmented assignment ===
+totals = {'photo': 1}
+rtype = 'photo'
+likes = 2
+totals[rtype] += likes
+assert totals == {'photo': 3}, 'subscript += updates existing dict item'
+
+calls = 0
+
+
+def key():
+    global calls
+    calls += 1
+    return 'photo'
+
+
+totals = {'photo': 10}
+totals[key()] += 5
+assert totals == {'photo': 15}, 'subscript += stores the computed result back'
+assert calls == 1, 'subscript += evaluates the index expression once'
+
+captured_total = {'photo': 1}
+captured_likes = 2
+
+
+def apply_captured_increment():
+    captured_total['photo'] += captured_likes
+
+
+apply_captured_increment()
+assert captured_total == {'photo': 3}, 'subscript += works with closure-captured names'
+
+walrus_key = None
+walrus_total = {'photo': 10}
+walrus_total[(walrus_key := 'photo')] += 4
+assert walrus_key == 'photo', 'subscript += allows walrus in the index expression'
+assert walrus_total == {'photo': 14}, 'subscript += with walrus index updates the selected item'
+
+try:
+    missing = {}
+    missing['photo'] += 1
+    assert False, 'subscript += on a missing dict key should raise KeyError'
+except KeyError as e:
+    assert e.args == ('photo',), 'subscript += missing key preserves the missing key in KeyError'
+
+try:
+    existing = {'photo': 'a'}
+    existing['photo'] += 1
+    assert False, 'subscript += with incompatible operand types should raise TypeError'
+except TypeError as e:
+    assert e.args == ('can only concatenate str (not "int") to str',), 'subscript += type error matches CPython'
+    assert existing == {'photo': 'a'}, 'failed subscript += does not overwrite the original dict item'
+
+# === Dict.get() method ===
+d = {'a': 1, 'b': 2}
+assert d.get('a') == 1, 'get existing'
+assert d.get('missing') is None, 'get missing returns None'
+assert d.get('missing', 'default') == 'default', 'get missing with default'
+
+# === Dict.pop() method ===
+d = {'a': 1, 'b': 2}
+assert d.pop('a') == 1, 'pop existing'
+assert d == {'b': 2}, 'pop removes key'
+
+d = {'a': 1}
+assert d.pop('missing', 'default') == 'default', 'pop missing with default'
+
+# === Dict with tuple key ===
+d = {(1, 2): 'value'}
+assert d[(1, 2)] == 'value', 'tuple key'
+
+# === Dict repr ===
+assert repr({}) == '{}', 'empty repr'
+assert repr({'a': 1}) == "{'a': 1}", 'repr with items'
+
+# === Dict self-reference ===
+d = {}
+d['self'] = d
+assert d['self'] is d, 'getitem self'
+
+d = {}
+assert d.get('missing', d) is d, 'get default same dict'
+
+# === Dict unpacking (PEP 448) ===
+a = {'x': 1, 'y': 2}
+b = {'y': 99, 'z': 3}
+assert {**a} == {'x': 1, 'y': 2}, 'single unpack'
+assert {**a, **b} == {'x': 1, 'y': 99, 'z': 3}, 'double unpack, later wins'
+assert {**a, 'y': 0} == {'x': 1, 'y': 0}, 'literal overrides unpacked key'
+assert {'y': 0, **a} == {'y': 2, 'x': 1}, 'unpack overrides earlier literal'
+assert {**a, 'z': 3} == {'x': 1, 'y': 2, 'z': 3}, 'unpack then new key'
+assert {**{}} == {}, 'unpack empty dict'
+assert {**a, **b, 'w': 4} == {'x': 1, 'y': 99, 'z': 3, 'w': 4}, 'complex mixed'
+assert list({**a, 'z': 3}.keys()) == ['x', 'y', 'z'], 'insertion order preserved'
+
+# === Dict unpack TypeError for non-mapping heap ref ===
+# Unpacking a Ref that is NOT a dict (e.g. a list) should raise TypeError
+try:
+    x = {**[1, 2, 3]}
+    assert False, 'expected TypeError'
+except TypeError as e:
+    assert str(e) == "'list' object is not a mapping", f'wrong error: {e}'

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

@@ -0,0 +1,4 @@
+# note cpython behaves weirdly if the dict is empty: https://github.com/python/cpython/issues/142396
+d = {1: 2}
+d.pop([], 'fallback')
+# Raise=TypeError("cannot use 'list' as a dict key (unhashable type: 'list')")

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

@@ -0,0 +1,9 @@
+{}.popitem()
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "dict__popitem_empty.py", line 1, in <module>
+    {}.popitem()
+    ~~~~~~~~~~~~
+KeyError: 'popitem(): dictionary is empty'
+"""

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

@@ -0,0 +1,3 @@
+d = {'a': 1}
+d['missing']
+# Raise=KeyError('missing')

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

@@ -0,0 +1,2 @@
+{{'a': 1}: 'value'}
+# Raise=TypeError("cannot use 'dict' as a dict key (unhashable type: 'dict')")

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

@@ -0,0 +1,2 @@
+{[1, 2]: 'value'}
+# Raise=TypeError("cannot use 'list' as a dict key (unhashable type: 'list')")

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

@@ -0,0 +1,2 @@
+{**42}
+# Raise=TypeError("'int' object is not a mapping")