superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,353 @@
+# === Basic nonlocal read/write ===
+def read_outer():
+    x = 10
+
+    def inner():
+        return x  # reads from outer scope
+
+    return inner()
+
+
+assert read_outer() == 10, 'nonlocal read'
+
+
+def write_outer():
+    x = 10
+
+    def inner():
+        nonlocal x
+        x = 20
+
+    inner()
+    return x
+
+
+assert write_outer() == 20, 'nonlocal write'
+
+
+# === Classic counter pattern ===
+def make_counter():
+    count = 0
+
+    def increment():
+        nonlocal count
+        count = count + 1
+        return count
+
+    return increment
+
+
+counter2 = make_counter()
+assert counter2() == 1, 'counter first call'
+assert counter2() == 2, 'counter second call'
+assert counter2() == 3, 'counter third call'
+
+
+# === Implicit capture (read without nonlocal) ===
+def implicit_capture():
+    a = 10
+    b = 20
+
+    def inner():
+        return a + b  # reads both from outer
+
+    return inner()
+
+
+assert implicit_capture() == 30, 'implicit capture multiple vars'
+
+
+# === Pass-through nesting ===
+def pass_through():
+    x = 1
+
+    def middle():
+        nonlocal x
+        x = x + 10
+
+        def inner():
+            nonlocal x
+            x = x + 100
+            return x
+
+        r1 = inner()  # returns 111
+        r2 = x  # x is now 111
+        return r1 + r2  # 222
+
+    return middle()
+
+
+assert pass_through() == 222, 'nonlocal pass through'
+
+
+# === Deep nesting (3 levels) ===
+def deep_nesting():
+    x = 1
+
+    def level2():
+        nonlocal x
+        x = x + 10
+
+        def level3():
+            nonlocal x
+            x = x + 100
+            return x
+
+        return level3()
+
+    return level2()
+
+
+assert deep_nesting() == 111, 'deep nesting'
+
+
+# === Deep nesting (4 levels) ===
+def deep_pass_through():
+    val = 1
+
+    def level1():
+        nonlocal val
+        val = val + 1
+
+        def level2():
+            nonlocal val
+            val = val + 10
+
+            def level3():
+                nonlocal val
+                val = val + 100
+                return val
+
+            return level3()
+
+        return level2()
+
+    result = level1()  # val: 1 -> 2 -> 12 -> 112
+    return (result, val)
+
+
+assert deep_pass_through() == (112, 112), 'deep pass through 4 levels'
+
+
+# === Multiple independent cells ===
+def multiple_cells():
+    a = 1
+    b = 10
+    c = 100
+
+    def modify_a():
+        nonlocal a
+        a = a + 1
+        return a
+
+    def modify_b():
+        nonlocal b
+        b = b + 10
+        return b
+
+    def modify_c():
+        nonlocal c
+        c = c + 100
+        return c
+
+    def read_all():
+        return a + b + c
+
+    r1 = modify_b()  # b = 20
+    r2 = modify_a()  # a = 2
+    r3 = modify_c()  # c = 200
+    r4 = read_all()  # 2 + 20 + 200 = 222
+    return (r1, r2, r3, r4)
+
+
+assert multiple_cells() == (20, 2, 200, 222), 'multiple independent cells'
+
+
+# === Shared cell (getter/setter pattern) ===
+def shared_cell():
+    x = 0
+
+    def getter():
+        return x
+
+    def setter(v):
+        nonlocal x
+        x = v
+
+    return (getter, setter)
+
+
+pair = shared_cell()
+getter = pair[0]
+setter = pair[1]
+assert getter() == 0, 'shared cell initial'
+setter(42)
+assert getter() == 42, 'shared cell after setter'
+
+
+# === Shared multiple vars ===
+def shared_multiple_vars():
+    x = 0
+    y = 0
+
+    def add_to_x(n):
+        nonlocal x
+        x = x + n
+        return x
+
+    def add_to_y(n):
+        nonlocal y
+        y = y + n
+        return y
+
+    def swap():
+        nonlocal x, y
+        tmp = x
+        x = y
+        y = tmp
+        return (x, y)
+
+    def get_both():
+        return (x, y)
+
+    return (add_to_x, add_to_y, swap, get_both)
+
+
+ops = shared_multiple_vars()
+add_x = ops[0]
+add_y = ops[1]
+swap = ops[2]
+get = ops[3]
+add_x(5)  # x=5
+add_y(10)  # y=10
+add_x(3)  # x=8
+swap()  # x=10, y=8
+assert get() == (10, 8), 'shared multiple vars with swap'
+
+
+# === Local and captured ===
+def local_and_captured():
+    x = 1
+
+    def inner():
+        nonlocal x
+        x = x + x
+        return x
+
+    before = x  # 1
+    middle = inner()  # 2
+    after = x  # 2
+    final = inner()  # 4
+    return (before, middle, after, final, x)
+
+
+assert local_and_captured() == (1, 2, 2, 4, 4), 'local and captured'
+
+
+# === Mixing global and nonlocal ===
+g1 = 100
+
+
+def global_and_nonlocal():
+    x = 1
+
+    def inner():
+        global g1
+        nonlocal x
+        g1 = g1 + 1
+        x = x + 10
+        return g1 + x
+
+    return inner()
+
+
+assert global_and_nonlocal() == 112, 'global and nonlocal together'
+
+
+# === Closure with global and nonlocal ===
+g2 = 1000
+
+
+def make_closure_global():
+    x = 1
+
+    def closure():
+        global g2
+        nonlocal x
+        result = g2 + x
+        g2 = g2 + 1
+        x = x + 10
+        return result
+
+    return closure
+
+
+c = make_closure_global()
+r1 = c()  # returns 1001
+r2 = c()  # returns 1012
+r3 = c()  # returns 1023
+assert (r1, r2, r3, g2) == (1001, 1012, 1023, 1003), 'closure with global and nonlocal'
+
+
+# === Closure creates closure ===
+def outer_factory():
+    outer_val = 10
+
+    def inner_factory():
+        nonlocal outer_val
+        inner_val = outer_val
+
+        def innermost():
+            nonlocal inner_val
+            inner_val = inner_val + 1
+            return inner_val
+
+        outer_val = outer_val + 100
+        return innermost
+
+    return inner_factory
+
+
+factory = outer_factory()
+closure1 = factory()  # inner_val=10, outer_val->110
+closure2 = factory()  # inner_val=110, outer_val->210
+r1 = closure1()  # 11
+r2 = closure1()  # 12
+r3 = closure2()  # 111
+r4 = closure1()  # 13
+assert (r1, r2, r3, r4) == (11, 12, 111, 13), 'closure creates closure'
+
+
+# === Augmented assignment with nonlocal ===
+def augmented_assign():
+    x = 10
+
+    def inner():
+        nonlocal x
+        x += 5
+
+    inner()
+    return x
+
+
+assert augmented_assign() == 15, 'augmented assign nonlocal'
+
+
+# === Cell contains closure ===
+def cell_contains_closure():
+    y = 100
+
+    def inner():
+        return y
+
+    x = inner  # x holds closure, x is also a cell var
+
+    def get_x():
+        nonlocal x
+        return x
+
+    f = get_x()
+    return f()
+
+
+assert cell_contains_closure() == 100, 'cell contains closure'

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

@@ -0,0 +1,40 @@
+# call-external
+# Tests for os.environ property
+
+import os
+
+# === os.environ property ===
+# os.environ returns a dict-like object
+env = os.environ
+
+# === os.environ key access ===
+assert env['VIRTUAL_HOME'] == '/virtual/home', 'environ key access VIRTUAL_HOME'
+assert os.environ['VIRTUAL_HOME'] == '/virtual/home', 'environ key access VIRTUAL_HOME'
+assert os.environ['VIRTUAL_USER'] == 'testuser', 'environ key access VIRTUAL_USER'
+assert os.environ['VIRTUAL_EMPTY'] == '', 'environ key access VIRTUAL_EMPTY'
+
+# === os.environ get method ===
+assert env.get('VIRTUAL_HOME') == '/virtual/home', 'environ.get existing key'
+assert os.environ.get('VIRTUAL_HOME') == '/virtual/home', 'environ.get existing key'
+assert os.environ.get('VIRTUAL_USER') == 'testuser', 'environ.get existing user'
+assert os.environ.get('NONEXISTENT_VAR_12345') is None, 'environ.get missing returns None'
+assert os.environ.get('NONEXISTENT_VAR_12345', 'default') == 'default', 'environ.get with default'
+
+# === os.environ length ===
+assert len(env) == 3, 'environ has 3 virtual entries'
+
+# === os.environ membership test ===
+assert 'VIRTUAL_HOME' in env, 'VIRTUAL_HOME in environ'
+assert 'VIRTUAL_HOME' in os.environ, 'VIRTUAL_HOME in environ'
+assert 'VIRTUAL_USER' in env, 'VIRTUAL_USER in environ'
+assert 'NONEXISTENT_VAR_12345' not in env, 'nonexistent not in environ'
+assert 'NONEXISTENT_VAR_12345' not in os.environ, 'nonexistent not in environ'
+
+# === os.environ keys/values/items ===
+keys = list(os.environ.keys())
+assert 'VIRTUAL_HOME' in keys, 'VIRTUAL_HOME in keys'
+assert 'VIRTUAL_USER' in keys, 'VIRTUAL_USER in keys'
+
+values = list(os.environ.values())
+assert '/virtual/home' in values, '/virtual/home in values'
+assert 'testuser' in values, 'testuser in values'

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

@@ -0,0 +1,5 @@
+# call-external
+import os
+
+os.getenv([1, 2, 3])
+# Raise=TypeError('str expected, not list')

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

@@ -0,0 +1,5 @@
+# call-external
+import os
+
+os.getenv(123)
+# Raise=TypeError('str expected, not int')

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

@@ -0,0 +1,3 @@
+# xfail=cpython
+1 + 2j
+# Raise=NotImplementedError('The monty syntax parser does not yet support complex constants')

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

@@ -0,0 +1,11 @@
+import pathlib
+
+# Verify that pathlib.Path can be called as an attribute
+p = pathlib.Path('a.txt')
+assert p.name == 'a.txt'
+
+# Verify that it still works when imported directly
+from pathlib import Path
+
+p2 = Path('b.txt')
+assert p2.name == 'b.txt'

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

@@ -0,0 +1,136 @@
+# call-external
+from pathlib import Path
+
+# === exists() ===
+assert Path('/virtual/file.txt').exists() == True, 'file exists'
+assert Path('/virtual/subdir').exists() == True, 'dir exists'
+assert Path('/virtual/subdir/deep').exists() == True, 'nested dir exists'
+assert Path('/nonexistent').exists() == False, 'nonexistent path'
+assert Path('/nonexistent/file.txt').exists() == False, 'nonexistent nested path'
+
+# === is_file() ===
+assert Path('/virtual/file.txt').is_file() == True, 'is_file true for file'
+assert Path('/virtual/subdir').is_file() == False, 'is_file false for dir'
+assert Path('/nonexistent').is_file() == False, 'is_file false for nonexistent'
+
+# === is_dir() ===
+assert Path('/virtual/subdir').is_dir() == True, 'is_dir true for dir'
+assert Path('/virtual/file.txt').is_dir() == False, 'is_dir false for file'
+assert Path('/nonexistent').is_dir() == False, 'is_dir false for nonexistent'
+
+# === is_symlink() ===
+assert Path('/virtual/file.txt').is_symlink() == False, 'is_symlink false (no symlinks in vfs)'
+assert Path('/nonexistent').is_symlink() == False, 'is_symlink false for nonexistent'
+
+# === read_text() ===
+assert Path('/virtual/file.txt').read_text() == 'hello world\n', 'read_text basic'
+assert Path('/virtual/empty.txt').read_text() == '', 'read_text empty file'
+assert Path('/virtual/subdir/nested.txt').read_text() == 'nested content', 'read_text nested'
+assert Path('/virtual/subdir/deep/file.txt').read_text() == 'deep', 'read_text deep nested'
+
+# === read_bytes() ===
+assert Path('/virtual/data.bin').read_bytes() == b'\x00\x01\x02\x03', 'read_bytes binary'
+assert Path('/virtual/empty.txt').read_bytes() == b'', 'read_bytes empty'
+assert Path('/virtual/file.txt').read_bytes() == b'hello world\n', 'read_bytes text file'
+
+# === stat() basic ===
+st = Path('/virtual/file.txt').stat()
+assert st.st_size == 12, 'stat size (len of "hello world\\n")'
+# 0o644 permissions + regular file type bits (0o100000)
+assert st.st_mode & 0o777 == 0o644, 'stat mode permissions'
+# Verify it's a regular file using raw mode bits
+# S_IFREG = 0o100000, so check that file type bits match
+assert st.st_mode & 0o170000 == 0o100000, 'stat is regular file'
+
+# === stat() directory ===
+st_dir = Path('/virtual/subdir').stat()
+# S_IFDIR = 0o040000, so check that file type bits match
+assert st_dir.st_mode & 0o170000 == 0o040000, 'stat is directory'
+assert st_dir.st_mode & 0o777 == 0o755, 'stat dir mode permissions'
+
+# === stat() index access ===
+st2 = Path('/virtual/file.txt').stat()
+assert st2[6] == 12, 'stat index access for st_size'
+assert st2[0] & 0o777 == 0o644, 'stat index access for st_mode'
+
+# === iterdir() ===
+entries = list(Path('/virtual').iterdir())
+assert len(entries) == 5, 'iterdir returns correct count'
+
+# iterdir() should return Path objects, not strings
+first_entry = entries[0]
+assert isinstance(first_entry, Path), f'iterdir should return Path objects, got {type(first_entry)}'
+
+# Path objects should have .name attribute
+names = [e.name for e in entries]
+assert 'file.txt' in names, 'iterdir contains file.txt'
+assert 'subdir' in names, 'iterdir contains subdir'
+assert 'data.bin' in names, 'iterdir contains data.bin'
+
+# Path objects should have .parent attribute
+assert entries[0].parent == Path('/virtual'), 'iterdir entry parent is correct'
+
+# === iterdir() nested ===
+nested_entries = list(Path('/virtual/subdir').iterdir())
+assert len(nested_entries) == 2, 'iterdir nested count'
+nested_names = [e.name for e in nested_entries]
+assert 'nested.txt' in nested_names, 'iterdir nested contains nested.txt'
+assert 'deep' in nested_names, 'iterdir nested contains deep'
+
+# === iterdir() entries can be used for further operations ===
+# Find the nested.txt entry and read it
+for entry in nested_entries:
+    if entry.name == 'nested.txt':
+        assert entry.read_text() == 'nested content', 'iterdir entry can be read'
+
+# === resolve() ===
+p = Path('/virtual/file.txt').resolve()
+assert str(p) == '/virtual/file.txt', 'resolve absolute path unchanged'
+
+# === absolute() ===
+p2 = Path('/virtual/subdir').absolute()
+assert str(p2) == '/virtual/subdir', 'absolute path unchanged'
+
+# === path concatenation with OS calls ===
+base = Path('/virtual')
+full = base / 'subdir' / 'nested.txt'
+assert full.read_text() == 'nested content', 'path concat then read'
+assert full.exists() == True, 'path concat then exists'
+
+# === write_text() ===
+Path('/virtual/new_file.txt').write_text('created by write_text')
+assert Path('/virtual/new_file.txt').read_text() == 'created by write_text', 'write_text creates file'
+# Overwrite existing file
+Path('/virtual/file.txt').write_text('overwritten')
+assert Path('/virtual/file.txt').read_text() == 'overwritten', 'write_text overwrites'
+
+# === write_bytes() ===
+Path('/virtual/binary.dat').write_bytes(b'\xff\xfe\xfd')
+assert Path('/virtual/binary.dat').read_bytes() == b'\xff\xfe\xfd', 'write_bytes creates file'
+
+# === mkdir() ===
+Path('/virtual/new_dir').mkdir()
+assert Path('/virtual/new_dir').is_dir() == True, 'mkdir creates directory'
+# mkdir with parents
+Path('/virtual/a/b/c').mkdir(parents=True)
+assert Path('/virtual/a/b/c').is_dir() == True, 'mkdir parents creates nested'
+# mkdir with exist_ok
+Path('/virtual/new_dir').mkdir(exist_ok=True)  # Should not raise
+
+# === unlink() ===
+Path('/virtual/to_delete.txt').write_text('delete me')
+assert Path('/virtual/to_delete.txt').exists() == True, 'file exists before unlink'
+Path('/virtual/to_delete.txt').unlink()
+assert Path('/virtual/to_delete.txt').exists() == False, 'unlink removes file'
+
+# === rmdir() ===
+Path('/virtual/empty_dir').mkdir()
+assert Path('/virtual/empty_dir').is_dir() == True, 'dir exists before rmdir'
+Path('/virtual/empty_dir').rmdir()
+assert Path('/virtual/empty_dir').exists() == False, 'rmdir removes directory'
+
+# === rename() ===
+Path('/virtual/old_name.txt').write_text('rename test')
+Path('/virtual/old_name.txt').rename(Path('/virtual/new_name.txt'))
+assert Path('/virtual/old_name.txt').exists() == False, 'rename removes old path'
+assert Path('/virtual/new_name.txt').read_text() == 'rename test', 'rename creates new path'

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

@@ -0,0 +1,12 @@
+# call-external
+from pathlib import Path
+
+Path('/nonexistent').read_text()
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "pathlib__os_read_error.py", line 4, in <module>
+    Path('/nonexistent').read_text()
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+FileNotFoundError: [Errno 2] No such file or directory: '/nonexistent'
+"""

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

@@ -0,0 +1,81 @@
+# === Path constructor ===
+from pathlib import Path
+
+p = Path('/usr/local/bin/python')
+assert str(p) == '/usr/local/bin/python', 'Path str should match input'
+
+# Constructor with multiple arguments
+assert str(Path('folder', 'file.txt')) == 'folder/file.txt', 'Path with two args joins'
+assert str(Path('/usr', 'local', 'bin')) == '/usr/local/bin', 'Path with three args joins'
+assert str(Path('start', '/absolute', 'end')) == '/absolute/end', 'absolute in middle replaces'
+
+# Constructor with no arguments
+assert str(Path()) == '.', 'Path() returns current dir'
+
+# === name property ===
+assert p.name == 'python', 'name should be final component'
+assert Path('/usr/local/bin/').name == 'bin', 'name should handle trailing slash'
+assert Path('/').name == '', 'root path should have empty name'
+assert Path('file.txt').name == 'file.txt', 'relative path name'
+
+# === parent property ===
+assert str(p.parent) == '/usr/local/bin', 'parent should remove last component'
+assert str(Path('/usr').parent) == '/', 'parent of first-level should be root'
+assert str(Path('/').parent) == '/', 'parent of root is root'
+assert str(Path('file.txt').parent) == '.', 'parent of relative without dir is .'
+
+# === stem property ===
+assert Path('/path/file.tar.gz').stem == 'file.tar', 'stem removes last extension'
+assert Path('/path/file.txt').stem == 'file', 'stem removes single extension'
+assert Path('/path/.bashrc').stem == '.bashrc', 'stem preserves hidden files'
+assert Path('/path/file').stem == 'file', 'stem without extension'
+
+# === suffix property ===
+assert Path('/path/file.tar.gz').suffix == '.gz', 'suffix is last extension'
+assert Path('/path/file.txt').suffix == '.txt', 'suffix with single extension'
+assert Path('/path/.bashrc').suffix == '', 'hidden file has no suffix'
+assert Path('/path/file').suffix == '', 'no extension means empty suffix'
+
+# === suffixes property ===
+assert Path('/path/file.tar.gz').suffixes == ['.tar', '.gz'], 'suffixes list'
+assert Path('/path/file.txt').suffixes == ['.txt'], 'single suffix as list'
+assert Path('/path/.bashrc').suffixes == [], 'hidden file has no suffixes'
+
+# === parts property ===
+assert Path('/usr/local/bin').parts == ('/', 'usr', 'local', 'bin'), 'absolute path parts'
+assert Path('usr/local').parts == ('usr', 'local'), 'relative path parts'
+assert Path('/').parts == ('/',), 'root path parts'
+
+# === is_absolute method ===
+assert Path('/usr/bin').is_absolute() == True, 'absolute path'
+assert Path('usr/bin').is_absolute() == False, 'relative path not absolute'
+assert Path('').is_absolute() == False, 'empty path not absolute'
+
+# === joinpath method ===
+assert str(Path('/usr').joinpath('local')) == '/usr/local', 'joinpath with one arg'
+assert str(Path('/usr').joinpath('local', 'bin')) == '/usr/local/bin', 'joinpath with two args'
+assert str(Path('/usr').joinpath('/etc')) == '/etc', 'joinpath with absolute replaces'
+assert str(Path('.').joinpath('file')) == 'file', 'joinpath from dot'
+
+# === with_name method ===
+assert str(Path('/path/file.txt').with_name('other.py')) == '/path/other.py', 'with_name replaces name'
+assert str(Path('file.txt').with_name('other.py')) == 'other.py', 'with_name on relative'
+
+# === with_suffix method ===
+assert str(Path('/path/file.txt').with_suffix('.py')) == '/path/file.py', 'with_suffix replaces'
+assert str(Path('/path/file.txt').with_suffix('')) == '/path/file', 'with_suffix removes'
+assert str(Path('/path/file').with_suffix('.txt')) == '/path/file.txt', 'with_suffix adds'
+
+# === / operator ===
+assert str(Path('/usr') / 'local') == '/usr/local', '/ operator joins'
+assert str(Path('/usr') / 'local' / 'bin') == '/usr/local/bin', '/ operator chains'
+
+# === as_posix method ===
+assert Path('/usr/bin').as_posix() == '/usr/bin', 'as_posix returns string'
+
+# === __fspath__ method (os.PathLike protocol) ===
+assert Path('/usr/bin').__fspath__() == '/usr/bin', '__fspath__ returns string'
+
+# === repr ===
+r = repr(Path('/usr/bin'))
+assert r == "PosixPath('/usr/bin')", f'repr should be PosixPath, got {r}'

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

@@ -0,0 +1,5 @@
+# Test that returning a cyclic dict doesn't crash (MontyObject cycle detection)
+d = {}
+d['self'] = d
+d
+# Return={'self': {...}}

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

@@ -0,0 +1,6 @@
+# Test composite cycle: list containing dict containing original list
+c = []
+e = {'list': c}
+c.append(e)
+c
+# Return=[{'list': [...]}]

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

@@ -0,0 +1,5 @@
+# Test that returning a cyclic list doesn't crash (MontyObject cycle detection)
+a = []
+a.append(a)
+a
+# Return=[[...]]

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

@@ -0,0 +1,6 @@
+# Test multiple references to the same cyclic object
+f = []
+f.append(f)
+g = [f, f]
+g
+# Return=[[[...]], [[...]]]

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

@@ -0,0 +1,2 @@
+range()
+# Raise=TypeError('range expected at least 1 argument, got 0')

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

@@ -0,0 +1,2 @@
+range(0, 10, 0)
+# Raise=ValueError('range() arg 3 must not be zero')