superacli 1.1.5 → 1.1.7

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

@@ -1,241 +0,0 @@
-# Tests for the re (regular expression) module - capture groups and grouping
-
-import re
-
-# === Capture groups ===
-m = re.search(r'(\w+)@(\w+)', 'user@host')
-assert m is not None, 're.search with groups finds a match'
-assert m.group(0) == 'user@host', 'group(0) is the full match'
-assert m.group(1) == 'user', 'group(1) is first capture'
-assert m.group(2) == 'host', 'group(2) is second capture'
-assert m.groups() == ('user', 'host'), 'groups() returns tuple of captures'
-
-# === group start/end/span with capture groups ===
-m = re.search(r'(\w+)@(\w+)', 'email: user@host here')
-assert m is not None, 'search with groups finds match'
-assert m.start(0) == 7, 'start(0) is full match start'
-assert m.end(0) == 16, 'end(0) is full match end'
-assert m.start(1) == 7, 'start(1) is group 1 start'
-assert m.end(1) == 11, 'end(1) is group 1 end'
-assert m.span(1) == (7, 11), 'span(1) is group 1 span'
-assert m.start(2) == 12, 'start(2) is group 2 start'
-assert m.end(2) == 16, 'end(2) is group 2 end'
-assert m.span(2) == (12, 16), 'span(2) is group 2 span'
-
-# === re.findall() with one group ===
-result = re.findall(r'(\d+)', 'a1 b22 c333')
-assert result == ['1', '22', '333'], 'findall with one group returns list of group strings'
-
-# === re.findall() with multiple groups ===
-result = re.findall(r'(\w+)=(\w+)', 'a=1 b=2')
-assert result == [('a', '1'), ('b', '2')], 'findall with multiple groups returns list of tuples'
-
-# === No groups: groups() returns empty tuple ===
-m = re.search(r'\d+', '42')
-assert m is not None, 'search with no groups finds match'
-assert m.groups() == (), 'groups() with no capture groups returns empty tuple'
-
-# === Backreferences ===
-m = re.search(r'(\w+)\s+\1', 'hello hello')
-assert m is not None, 'backreference finds repeated word'
-assert m.group(0) == 'hello hello', 'backreference full match'
-assert m.group(1) == 'hello', 'backreference group'
-
-# === Invalid group index ===
-m = re.search(r'(\w+)', 'hello')
-assert m is not None, 'search with group finds match'
-try:
-    m.group(2)
-    assert False, 'Accessing invalid group index should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group'
-try:
-    m.group('foo')
-    assert False, 'Accessing group with non-integer index should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group'
-
-# === re.sub() replacement with backreferences ===
-result = re.sub(r'(\w+)=(\w+)', r'\2=\1', 'a=1 b=2')
-assert result == '1=a 2=b', 're.sub with backreferences swaps groups'
-
-# === Negative group index ===
-m = re.search(r'(\w+)', 'hello')
-assert m is not None, 'search with group finds match'
-try:
-    m.group(-1)
-    assert False, 'Negative group index should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'negative group raises IndexError with "no such group" message'
-
-# === Out-of-range group index ===
-m = re.search(r'(\w+)', 'hello')
-assert m is not None, 'search with group finds match'
-try:
-    m.group(999)
-    assert False, 'Out-of-range group index should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'out-of-range group raises IndexError with "no such group" message'
-
-# === Non-integer group argument: float ===
-m = re.search(r'(\w+)', 'hello')
-assert m is not None, 'search with group finds match'
-try:
-    m.group(1.5)
-    assert False, 'Float group argument should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'float group arg raises IndexError'
-
-# === Non-integer group argument: string ===
-m = re.search(r'(\w+)', 'hello')
-assert m is not None, 'search with group finds match'
-try:
-    m.group('1')
-    assert False, 'String group argument should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'string group arg raises IndexError'
-
-# === Non-integer group argument: None ===
-m = re.search(r'(\w+)', 'hello')
-assert m is not None, 'search with group finds match'
-try:
-    m.group(None)
-    assert False, 'None group argument should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'None group arg raises IndexError'
-
-# === Negative group index for start() ===
-m = re.search(r'(\w+)@(\w+)', 'user@host')
-assert m is not None, 'search with groups finds match'
-try:
-    m.start(-1)
-    assert False, 'Negative start index should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'negative start raises IndexError with "no such group" message'
-
-# === Out-of-range group index for start() ===
-m = re.search(r'(\w+)@(\w+)', 'user@host')
-assert m is not None, 'search with groups finds match'
-try:
-    m.start(999)
-    assert False, 'Out-of-range start index should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'out-of-range start raises IndexError'
-
-# === Non-integer argument for start() ===
-m = re.search(r'(\w+)', 'hello')
-assert m is not None, 'search with group finds match'
-try:
-    m.start(1.5)
-    assert False, 'Float start argument should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'float start arg raises IndexError'
-
-# === Negative group index for end() ===
-m = re.search(r'(\w+)', 'hello')
-assert m is not None, 'search with group finds match'
-try:
-    m.end(-2)
-    assert False, 'Negative end index should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'negative end raises IndexError with "no such group" message'
-
-# === Out-of-range group index for end() ===
-m = re.search(r'(\w+)', 'hello')
-assert m is not None, 'search with group finds match'
-try:
-    m.end(100)
-    assert False, 'Out-of-range end index should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'out-of-range end raises IndexError'
-
-# === Non-integer argument for end() ===
-m = re.search(r'(\w+)', 'hello')
-assert m is not None, 'search with group finds match'
-try:
-    m.end('0')
-    assert False, 'String end argument should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'string end arg raises IndexError'
-
-# === Negative group index for span() ===
-m = re.search(r'(\w+)', 'hello')
-assert m is not None, 'search with group finds match'
-try:
-    m.span(-1)
-    assert False, 'Negative span index should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'negative span raises IndexError with "no such group" message'
-
-# === Out-of-range group index for span() ===
-m = re.search(r'(\w+)@(\w+)', 'user@host')
-assert m is not None, 'search with groups finds match'
-try:
-    m.span(5)
-    assert False, 'Out-of-range span index should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'out-of-range span raises IndexError'
-
-# === Non-integer argument for span() ===
-m = re.search(r'(\w+)', 'hello')
-assert m is not None, 'search with group finds match'
-try:
-    m.span(None)
-    assert False, 'None span argument should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'None span arg raises IndexError'
-
-# === Accessing unmatched optional group returns None ===
-# Optional groups that don't match return None instead of raising an error
-m = re.search(r'(\w+)?@(\w+)', '@host')
-assert m is not None, 'search with optional group finds match'
-assert m.group(1) is None, 'unmatched optional group returns None'
-assert m.start(1) == -1, 'start of unmatched optional group returns -1'
-assert m.end(1) == -1, 'end of unmatched optional group returns -1'
-assert m.span(1) == (-1, -1), 'span of unmatched optional group returns (-1, -1)'
-
-# === Named group access with m.group('name') ===
-m = re.search(r'(?P<first>\w+)\s+(?P<second>\w+)', 'hello world')
-assert m is not None, 'named group search finds match'
-assert m.group('first') == 'hello', "group('first') returns first named group"
-assert m.group('second') == 'world', "group('second') returns second named group"
-assert m.group(1) == 'hello', 'named group is also accessible by index'
-assert m.group(2) == 'world', 'named group is also accessible by index'
-assert m.group(0) == 'hello world', 'group(0) still returns full match'
-
-# Named group with invalid name
-try:
-    m.group('nonexistent')
-    assert False, 'non-existent named group should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'non-existent named group error message'
-
-# === m.group() with multiple arguments ===
-m = re.search(r'(\w+)\s+(\w+)\s+(\w+)', 'a b c')
-assert m is not None, 'multi-group search finds match'
-result = m.group(1, 2)
-assert result == ('a', 'b'), 'group(1, 2) returns tuple of two groups'
-
-result = m.group(1, 2, 3)
-assert result == ('a', 'b', 'c'), 'group(1, 2, 3) returns tuple of three groups'
-
-result = m.group(0, 1)
-assert result == ('a b c', 'a'), 'group(0, 1) includes full match'
-
-# === m.groupdict() ===
-m = re.search(r'(?P<first>\w+)\s+(?P<second>\w+)', 'hello world')
-assert m is not None, 'named group search for groupdict'
-d = m.groupdict()
-assert d == {'first': 'hello', 'second': 'world'}, 'groupdict returns correct dict'
-
-# groupdict with no named groups
-m = re.search(r'(\w+)\s+(\w+)', 'hello world')
-assert m is not None, 'unnamed group search for groupdict'
-d = m.groupdict()
-assert d == {}, 'groupdict with no named groups returns empty dict'
-
-# groupdict with unmatched optional named group
-m = re.search(r'(?P<first>\w+)?@(?P<second>\w+)', '@host')
-assert m is not None, 'optional named group search for groupdict'
-d = m.groupdict()
-assert d == {'first': None, 'second': 'host'}, 'groupdict includes unmatched named groups as None'

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

@@ -1,148 +0,0 @@
-# Tests for the re (regular expression) module - Match object
-
-import re
-
-# === Match .string attribute ===
-m = re.search('hello', 'say hello')
-assert m is not None, 'search finds match for .string test'
-assert m.string == 'say hello', '.string returns the input string'
-
-# === Match truthiness ===
-m = re.search(r'\d+', '123')
-assert m, 'Match objects are truthy'
-
-# === Match repr ===
-m = re.search(r'\d+', 'abc 42 def')
-assert repr(m) == "<re.Match object; span=(4, 6), match='42'>", 'Match repr'
-
-# === Object basic ===
-assert bool(re.search(r'\w+', 'hello'))
-assert isinstance(re.search(r'\w+', 'hello'), re.Match), 're.search returns re.Match instance'
-assert str(type(re.search(r'\w+', 'hello'))) == "<class 're.Match'>", 'type of search match is re.Match'
-
-# === Match equality - Match objects are not comparable ===
-m1 = re.search(r'\w+', 'hello')
-m2 = re.search(r'\w+', 'hello')
-assert (m1 == m2) == False, 'different Match objects are not equal'
-assert m1 != m2, 'Match objects with same content are not equal'
-
-# === Match methods are reusable on same object ===
-m = re.search(r'(\w+)@(\w+)', 'user@host')
-assert m is not None, 'search finds match'
-assert m.group(0) == 'user@host', 'first call to group(0) works'
-assert m.group(0) == 'user@host', 'second call to group(0) works'
-assert m.group(1) == 'user', 'call to group(1) works'
-assert m.start(1) == 0, 'start(1) works'
-assert m.end(1) == 4, 'end(1) works'
-assert m.span(0) == (0, 9), 'span(0) works'
-
-# === .string attribute is accessible multiple times ===
-m = re.search(r'hello', 'say hello world')
-assert m is not None, 'search finds match'
-assert m.string == 'say hello world', 'first access to .string works'
-assert m.string == 'say hello world', 'second access to .string works'
-
-# === Match object with empty string ===
-m = re.search(r'', 'hello')
-assert m is not None, 'empty pattern matches'
-assert m.string == 'hello', '.string returns input for empty match'
-assert m.group(0) == '', 'empty match group(0) is empty string'
-
-# === Match object from match() function ===
-m = re.match(r'(\w+)', 'hello world')
-assert m is not None, 're.match finds match'
-assert m.group(0) == 'hello', 'match() returns correct match'
-assert m.start(0) == 0, 'match starts at position 0'
-assert m.string == 'hello world', '.string returns full input'
-
-# === Match object from fullmatch() function ===
-m = re.fullmatch(r'\w+', 'hello')
-assert m is not None, 're.fullmatch finds exact match'
-assert m.group(0) == 'hello', 'fullmatch returns correct match'
-assert m.start(0) == 0, 'fullmatch starts at position 0'
-assert m.end(0) == 5, 'fullmatch ends at correct position'
-
-# === Match repr basic format ===
-m = re.search(r'\d+', 'abc 42 def')
-assert repr(m) == "<re.Match object; span=(4, 6), match='42'>", 'Match repr basic format'
-
-m = re.search(r'\w+', 'hello')
-assert repr(m) == "<re.Match object; span=(0, 5), match='hello'>", 'Match repr at start'
-
-m = re.search(r'', 'hello')
-assert repr(m) == "<re.Match object; span=(0, 0), match=''>", 'Match repr empty match'
-
-# === Match repr with special characters ===
-p = re.compile(r'a.b', re.DOTALL)
-m = p.search('a\nb')
-assert m is not None, 'DOTALL match for repr test'
-r = repr(m)
-assert r == "<re.Match object; span=(0, 3), match='a\\nb'>", 'Match repr escapes newline'
-
-m = re.search(r'a.b', 'a\tb')
-assert m is not None, 'tab match for repr test'
-r = repr(m)
-assert r == "<re.Match object; span=(0, 3), match='a\\tb'>", 'Match repr escapes tab'
-
-# backslash in matched text
-m = re.search(r'a.b', 'a\\b')
-assert m is not None, 'backslash match for repr test'
-r = repr(m)
-assert r == "<re.Match object; span=(0, 3), match='a\\\\b'>", 'Match repr escapes backslash'
-
-# carriage return in matched text
-p = re.compile(r'a.b', re.DOTALL)
-m = p.search('a\rb')
-assert m is not None, 'carriage return match for repr test'
-r = repr(m)
-assert r == "<re.Match object; span=(0, 3), match='a\\rb'>", 'Match repr escapes carriage return'
-
-# single quote in matched text — repr switches to double quotes
-m = re.search(r'a.b', "a'b")
-assert m is not None, 'single quote match for repr test'
-r = repr(m)
-assert r == '<re.Match object; span=(0, 3), match="a\'b">', 'Match repr handles single quote'
-
-# double quote in matched text — repr uses single quotes
-m = re.search(r'a.b', 'a"b')
-assert m is not None, 'double quote match for repr test'
-r = repr(m)
-assert r == "<re.Match object; span=(0, 3), match='a\"b'>", 'Match repr handles double quote'
-
-# === Pattern repr ===
-p = re.compile('hello')
-assert repr(p) == "re.compile('hello')", 'Pattern repr simple string'
-
-p = re.compile(r'\n\t')
-assert repr(p) == "re.compile('\\\\n\\\\t')", 'Pattern repr with escape sequences in pattern'
-
-# === Bool as group index ===
-m = re.search(r'(\w+)\s+(\w+)', 'hello world')
-assert m is not None, 'search for bool group test'
-assert m.group(True) == 'hello', 'group(True) is group(1)'
-assert m.group(False) == 'hello world', 'group(False) is group(0)'
-assert m.start(True) == 0, 'start(True) is start(1)'
-assert m.end(True) == 5, 'end(True) is end(1)'
-assert m.span(True) == (0, 5), 'span(True) is span(1)'
-assert m.span(False) == (0, 11), 'span(False) is span(0)'
-
-# === m[N] subscript access ===
-m = re.search(r'(\w+)\s+(\w+)', 'hello world')
-assert m is not None, 'search for subscript test'
-assert m[0] == 'hello world', 'm[0] is full match'
-assert m[1] == 'hello', 'm[1] is first group'
-assert m[2] == 'world', 'm[2] is second group'
-
-# subscript with named groups
-m = re.search(r'(?P<first>\w+)\s+(?P<second>\w+)', 'hello world')
-assert m is not None, 'search for named subscript test'
-assert m['first'] == 'hello', "m['first'] accesses named group"
-assert m['second'] == 'world', "m['second'] accesses named group"
-assert m[1] == 'hello', 'm[1] also works with named groups'
-
-# subscript with invalid index
-try:
-    m[99]
-    assert False, 'out-of-range subscript should raise IndexError'
-except IndexError as e:
-    assert str(e) == 'no such group', 'subscript IndexError message'

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

@@ -1,26 +0,0 @@
-# Test that dropping deeply nested containers doesn't crash (stack overflow).
-# Heap::dec_ref recurses in Rust when freeing child references, so deeply
-# nested containers can overflow the Rust call stack during cleanup.
-# CPython handles this fine (its dealloc uses an iterative trashcan mechanism).
-# Once fixed (iterative dec_ref), this should work without crashing.
-
-# === Deep list drop ===
-x = [1]
-for _ in range(10000):
-    x = [x]
-x = None  # triggers recursive dec_ref chain
-assert True, 'survived deep list drop'
-
-# === Deep tuple drop ===
-y = (1,)
-for _ in range(10000):
-    y = (y,)
-y = None  # triggers recursive dec_ref chain
-assert True, 'survived deep tuple drop'
-
-# === Deep dict drop ===
-z = {'a': 1}
-for _ in range(10000):
-    z = {'a': z}
-z = None  # triggers recursive dec_ref chain
-assert True, 'survived deep dict drop'

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

@@ -1,23 +0,0 @@
-# Test that deeply nested lists don't crash during equality comparison
-# Monty raises RecursionError at depth limit, CPython handles in C code
-a = []
-b = []
-for _ in range(30):  # Use lower depth that works within unified recursion limit
-    a = [a]
-    b = [b]
-
-# Should not crash
-result = a == b
-assert isinstance(result, bool), 'comparison should return a bool'
-assert result == True, 'structurally equal nested lists should be equal'
-
-# Test non-equal nested lists
-c = []
-for _ in range(30):
-    c = [c]
-c = [1]  # Make the innermost different
-for _ in range(29):
-    c = [c]
-
-result2 = a == c
-assert result2 == False, 'structurally different nested lists should not be equal'

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

@@ -1,46 +0,0 @@
-# Test that hashing deeply nested containers raises RecursionError instead
-# of crashing with a Rust stack overflow.
-
-# === Deep tuple hash ===
-x = (1,)
-for _ in range(10000):
-    x = (x,)
-
-try:
-    h = hash(x)
-    assert isinstance(h, int), 'hash should return an int'
-except RecursionError:
-    pass  # acceptable if depth guard triggers
-
-# === Deep frozenset hash ===
-y = frozenset({1})
-for _ in range(10000):
-    y = frozenset({y})
-
-try:
-    h = hash(y)
-    assert isinstance(h, int), 'hash should return an int'
-except RecursionError:
-    pass  # acceptable if depth guard triggers
-
-# === Deep tuple as dict key (triggers hash) ===
-z = (1,)
-for _ in range(10000):
-    z = (z,)
-
-d = {}
-try:
-    d[z] = 'value'
-except RecursionError:
-    pass  # acceptable if depth guard triggers
-
-# === Deep tuple as set element (triggers hash) ===
-w = (1,)
-for _ in range(10000):
-    w = (w,)
-
-s = set()
-try:
-    s.add(w)
-except RecursionError:
-    pass  # acceptable if depth guard triggers

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

@@ -1,12 +0,0 @@
-# Test that deeply nested lists don't crash during repr()
-# Monty truncates with "..." at depth limit, CPython handles in C code
-x = []
-for _ in range(200):
-    x = [x]
-
-# Should not crash - either returns full repr or truncated with "..."
-result = repr(x)
-assert isinstance(result, str), 'repr should return a string'
-assert result.startswith('['), 'repr should start with ['
-# Either full repr or truncated
-assert result.endswith(']') or '...' in result, 'repr should end with ] or contain ...'

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

@@ -1,13 +0,0 @@
-# Test that recursive function calls hit the recursion limit
-# This uses Python function call recursion which both CPython and Monty limit
-
-
-def recurse(n):
-    if n == 0:
-        return 0
-    return recurse(n - 1) + 1
-
-
-# This should raise RecursionError in both interpreters
-recurse(2000)
-# Raise=RecursionError('maximum recursion depth exceeded')

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

@@ -1,18 +0,0 @@
-# Mutual reference cycle: a contains b, b contains a
-# This creates a cycle where:
-#   - a has refcount 2 (variable 'a' + being inside b)
-#   - b has refcount 2 (variable 'b' + being inside a)
-# Without cycle detection, when both variables go out of scope:
-#   - a's refcount drops to 1 (still in b)
-#   - b's refcount drops to 1 (still in a)
-#   - Neither reaches 0, neither is freed (memory leak)
-#
-# NOTE: We return len(b) instead of b because repr(b) would cause infinite
-# recursion / stack overflow (a separate bug - Python handles this by printing [...]
-# for cyclic references)
-a = []
-b = []
-a.append(b)
-b.append(a)
-len(b)
-# ref-counts={'a': 2, 'b': 2}

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

@@ -1,12 +0,0 @@
-# Self-referential list: a contains itself
-# This creates a cycle where a's refcount is 2 (variable + self-reference)
-# Without cycle detection, when 'a' goes out of scope, refcount drops to 1
-# but the object is never freed (memory leak)
-#
-# NOTE: We return len(a) instead of a because repr(a) would cause infinite
-# recursion / stack overflow (a separate bug - Python handles this by printing [...]
-# for cyclic references)
-a = []
-a.append(a)
-len(a)
-# ref-counts={'a': 2}

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

@@ -1,5 +0,0 @@
-k = 'key'
-v = [1, 2]
-d = {k: v}
-d
-# ref-counts={'v': 2, 'd': 2}

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

@@ -1,5 +0,0 @@
-v = [1, 2]
-d = {0: v}
-x = d[0]
-x
-# ref-counts={'v': 4, 'd': 1, 'x': 4}

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

@@ -1,14 +0,0 @@
-inner = ('x',)
-wrapped = (inner,)
-empty = []
-rhs = [wrapped, empty]
-
-try:
-    {}.keys() & rhs
-    assert False, 'dict_keys intersection should reject unhashable iterable items'
-except TypeError as e:
-    assert str(e) == "cannot use 'list' as a set element (unhashable type: 'list')", (
-        'dict_keys intersection should surface the recoverable set-element hash error'
-    )
-
-# ref-counts={'inner': 2, 'wrapped': 2, 'empty': 2, 'rhs': 1}

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

@@ -1,6 +0,0 @@
-v1 = [1]
-v2 = [2]
-d = {0: v1}
-d[0] = v2
-d
-# ref-counts={'v1': 1, 'v2': 2, 'd': 2}

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

@@ -1,16 +0,0 @@
-# Test that GatherFuture and coroutines are properly cleaned up after gather completes.
-# The strict matching check will fail if the GatherFuture leaks (heap_count > unique_refs).
-import asyncio
-
-
-async def task1():
-    return 1
-
-
-async def task2():
-    return 2
-
-
-result = await asyncio.gather(task1(), task2())  # pyright: ignore
-result
-# ref-counts={'result': 2, 'asyncio': 1}

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

@@ -1,18 +0,0 @@
-# Test that GatherFuture and coroutines are properly cleaned up when a task raises.
-# When one task fails, sibling tasks should be cancelled and all resources freed.
-import asyncio
-
-
-async def task_ok():
-    return 1
-
-
-async def task_fail():
-    raise ValueError('task failed')
-
-
-try:
-    result = await asyncio.gather(task_ok(), task_fail())  # pyright: ignore
-except ValueError:
-    pass
-# ref-counts={'asyncio': 1}

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

@@ -1,25 +0,0 @@
-# Test that nested GatherFuture is properly cleaned up when outer task is cancelled.
-# When one task in an outer gather fails, sibling tasks (including those with inner gathers)
-# should be cancelled and all GatherFutures properly cleaned up.
-import asyncio
-
-
-async def inner_task():
-    return 1
-
-
-async def task_with_inner_gather():
-    # This inner gather should be cancelled when the outer gather fails
-    result = await asyncio.gather(inner_task(), inner_task())
-    return result
-
-
-async def task_fail():
-    raise ValueError('outer task failed')
-
-
-try:
-    result = await asyncio.gather(task_with_inner_gather(), task_fail())  # pyright: ignore
-except ValueError:
-    pass
-# ref-counts={'asyncio': 1}

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

@@ -1,4 +0,0 @@
-x = 42
-y = [1, 2]
-y
-# ref-counts={'y': 2}