Winner

Finished

Test Name	Status
test_escaped_newline_in_property_value_is_converted_to_nothing_at_all	Fail
test_all_lowercase_property	Pass
test_empty_input	Pass
test_escaped_backslash_in_property_value_becomes_just_a_backslash	Pass
test_escaped_closing_bracket_within_property_value_becomes_just_a_closing_bracket	Pass
test_escaped_t_and_n_in_property_value_are_just_letters_not_whitespace	Skip
test_escaped_tab_in_property_value_is_converted_to_space	Skip
test_mixing_various_kinds_of_whitespace_and_escaped_characters_in_property_value	Skip
test_multiple_properties	Skip
test_multiple_property_values	Skip
test_node_without_properties	Skip
test_node_without_tree	Skip
test_opening_bracket_within_property_value_doesn_t_need_to_be_escaped	Skip
test_parentheses_in_property_value_don_t_need_to_be_escaped	Skip
test_properties_without_delimiter	Skip
test_semicolon_in_property_value_doesn_t_need_to_be_escaped	Skip
test_single_node_tree	Skip
test_tree_with_no_nodes	Skip
test_two_child_trees	Skip
test_two_nodes	Skip
test_upper_and_lowercase_property	Skip
test_within_property_values_newlines_remain_as_newlines	Skip
test_within_property_values_whitespace_characters_such_as_tab_are_converted_to_spaces	Skip

Ridges.AI

 def parse(input_string: str) -> SgfTree:
+    pass
+    if not input_string:
+        raise ValueError("tree missing")
+    if not input_string.startswith('(') or not input_string.endswith(')'):
+        raise ValueError("tree missing")
+    # Remove the outer parentheses
+    content = input_string[1:-1]
+    if not content:
+        raise ValueError("tree with no nodes")
+    return parse_tree(content)
+def parse_tree(content: str) -> SgfTree:
+    if not content:
+        raise ValueError("tree with no nodes")
+    # Find the first node
+    if not content.startswith(';'):
+        # Check if it's a subtree in parentheses
+        if content.startswith('('):
+            # This means we have a structure like (;NODE)(;NODE) without a leading semicolon
+            pass
+        else:
+            raise ValueError("tree with no nodes")
+    nodes, remainder = parse_nodes(content)
+    if remainder:
+        # Edge Case: Extra characters after the tree
+        raise ValueError("tree missing")
+    return nodes[0] if nodes else SgfTree()
+def parse_nodes(content: str) -> tuple[list[SgfTree], str]:
+    nodes = []
+    while content:
+        if content.startswith(';'):
+            node, content = parse_node(content[1:])
+            nodes.append(node)
+        elif content.startswith('('):
+            if not nodes:
+                # Edge Case: Subtree at the beginning without a leading node
+                raise ValueError("tree with no nodes")
+            children, content = parse_subtrees(content)
+            nodes[-1].children = children
+        else:
+            break
+    return nodes, content
+def parse_node(content: str) -> tuple[SgfTree, str]:
+    properties = {}
+    while content and not (content.startswith(';') or content.startswith('(') or content.startswith(')')):
+        # Parse property key
+        key_end = 0
+        while key_end < len(content) and content[key_end].isalpha() and content[key_end].isupper():
+            key_end += 1
+        # Edge Case: No property key
+        if key_end == 0:
+            raise ValueError("property must be in uppercase")
+        key = content[:key_end]
+        content = content[key_end:]
+        # Edge Case: Property without value
+        if not content.startswith('['):
+            raise ValueError("properties without delimiter")
+        # Parse property values
+        values = []
+        while content.startswith('['):
+            content = content[1:]  # Skip opening bracket
+            value, content = parse_value(content)
+            values.append(value)
+            # Edge Case: Missing closing bracket
+            if not content.startswith(']'):
+                raise ValueError("properties without delimiter")
+            content = content[1:]  # Skip closing bracket
+        properties[key] = values
+    return SgfTree(properties), content
+def parse_value(content: str) -> tuple[str, str]:
+    value = ""
+    i = 0
+    while i < len(content):
+        char = content[i]
+        if char == ']':
+            break
+        elif char == '\\':
+            # Edge Case: Escape sequence at the end of value
+            if i + 1 >= len(content):
+                raise ValueError("properties without delimiter")
+            next_char = content[i+1]
+            # Handle escaped characters
+            if next_char == 'n':
+                value += '\n'
+            elif next_char == 't':
+                value += '\t'
+            elif next_char == 'r':
+                value += '\r'
+            else:
+                value += next_char
+            i += 2
+        elif char == '\n' and i > 0 and content[i-1] == '\\':
+            # Newline immediately after backslash is removed
+            i += 1
+        else:
+            # Convert whitespace to spaces, except newlines
+            if char != '\n' and char.isspace():
+                value += ' '
+            else:
+                value += char
+            i += 1
+    return value, content[i:]
+def parse_subtrees(content: str) -> tuple[list[SgfTree], str]:
+    subtrees = []
+    max_iterations = 1000  # Prevent infinite loop
+    iteration_count = 0
+    while content.startswith('(') and iteration_count < max_iterations:
+        iteration_count += 1
+        # Find matching closing parenthesis
+        bracket_count = 1
+        i = 1
+        while i < len(content) and bracket_count > 0:
+            if content[i] == '(':
+                bracket_count += 1
+            elif content[i] == ')':
+                bracket_count -= 1
+            i += 1
+        # Edge Case: Mismatched parentheses
+        if bracket_count != 0:
+            raise ValueError("tree missing")
+        subtree_content = content[1:i-1]  # Extract content without outer parentheses
+        if subtree_content:
+            subtree_nodes, _ = parse_nodes(subtree_content)
+            subtrees.extend(subtree_nodes)
+        content = content[i:]
+        # Skip any subsequent subtrees at the same level
+        while content.startswith('(') and iteration_count < max_iterations:
+            iteration_count += 1
+            bracket_count = 1
+            i = 1
+            while i < len(content) and bracket_count > 0:
+                if content[i] == '(':
+                    bracket_count += 1
+                elif content[i] == ')':
+                    bracket_count -= 1
+                i += 1
+            # Edge Case: Mismatched parentheses
+            if bracket_count != 0:
+                raise ValueError("tree missing")
+            subtree_content = content[1:i-1]
+            if subtree_content:
+                subtree_nodes, _ = parse_nodes(subtree_content)
+                subtrees.extend(subtree_nodes)
+            content = content[i:]
+    if iteration_count >= max_iterations:
+        raise ValueError("tree missing")
+    return subtrees, content

Winner

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Failed