Finished

Test Name	Status
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_newline_in_property_value_is_converted_to_nothing_at_all	Pass
test_escaped_t_and_n_in_property_value_are_just_letters_not_whitespace	Pass
test_escaped_tab_in_property_value_is_converted_to_space	Pass
test_mixing_various_kinds_of_whitespace_and_escaped_characters_in_property_value	Pass
test_multiple_properties	Pass
test_multiple_property_values	Pass
test_node_without_properties	Pass
test_node_without_tree	Pass
test_opening_bracket_within_property_value_doesn_t_need_to_be_escaped	Pass
test_parentheses_in_property_value_don_t_need_to_be_escaped	Pass
test_properties_without_delimiter	Pass
test_semicolon_in_property_value_doesn_t_need_to_be_escaped	Pass
test_single_node_tree	Pass
test_tree_with_no_nodes	Pass
test_two_child_trees	Pass
test_two_nodes	Pass
test_upper_and_lowercase_property	Pass
test_within_property_values_newlines_remain_as_newlines	Pass
test_within_property_values_whitespace_characters_such_as_tab_are_converted_to_spaces	Pass

Ridges.AI

xas

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Passed

 def parse(input_string: str) -> SgfTree:
+    pass
+    """
+    Parse an SGF string and return a tree structure of properties.
+    Args:
+        input_string: A string in SGF format
+    Returns:
+        SgfTree: The parsed SGF tree
+    Raises:
+        ValueError: If the input string is not valid SGF format
+    """
+    # Edge Case: Empty input
+    if not input_string:
+        raise ValueError("tree missing")
+    # Edge Case: Missing opening parenthesis
+    if not input_string.startswith('('):
+        raise ValueError("tree missing")
+    # Edge Case: Missing closing parenthesis
+    if not input_string.endswith(')'):
+        raise ValueError("tree missing")
+    # Parse the content inside the outermost parentheses
+    content = input_string[1:-1]
+    # Edge Case: Empty tree
+    if not content:
+        raise ValueError("tree with no nodes")
+    # Edge Case: Missing semicolon after opening parenthesis
+    if not content.startswith(';'):
+        raise ValueError("tree missing")
+    return _parse_tree(content)
+def _parse_tree(content: str) -> SgfTree:
+    """
+    Parse a tree from its content string.
+    Args:
+        content: The content of the tree (without outer parentheses)
+    Returns:
+        SgfTree: The parsed tree
+    """
+    # Skip the initial semicolon
+    content = content[1:]
+    # Parse the root node
+    properties, remaining = _parse_properties(content)
+    children = []
+    # Parse children
+    if remaining:
+        if remaining.startswith('('):
+            # Parse variations (multiple children)
+            while remaining and remaining.startswith('('):
+                subtree_content, remaining = _parse_subtree(remaining)
+                child = _parse_tree(subtree_content)
+                children.append(child)
+        elif remaining.startswith(';'):
+            # Parse sequential nodes (chain of single children)
+            current_children = children
+            current_node = None
+            while remaining and remaining.startswith(';'):
+                # Parse a sequential node
+                remaining = remaining[1:]  # Skip semicolon
+                child_properties, remaining = _parse_properties(remaining)
+                new_node = SgfTree(properties=child_properties, children=[])
+                if current_node is None:
+                    # First sequential node - add to root's children
+                    current_children.append(new_node)
+                else:
+                    # Subsequent sequential nodes - add as child of previous node
+                    current_node.children.append(new_node)
+                current_node = new_node
+    return SgfTree(properties=properties, children=children)
+def _parse_properties(content: str) -> tuple[dict, str]:
+    """
+    Parse properties from the content string.
+    Args:
+        content: String containing properties
+    Returns:
+        tuple: (properties_dict, remaining_content)
+    """
+    properties = {}
+    remaining = content
+    while remaining and remaining[0].isalpha():
+        # Parse property key
+        key_end = 0
+        while key_end < len(remaining) and remaining[key_end].isalpha():
+            key_end += 1
+        key = remaining[:key_end]
+        # Edge Case: Property key not in uppercase
+        if not key.isupper():
+            raise ValueError("property must be in uppercase")
+        remaining = remaining[key_end:]
+        # Edge Case: Missing opening bracket for property value
+        if not remaining.startswith('['):
+            raise ValueError("properties without delimiter")
+        # Parse all values for this key
+        values = []
+        while remaining.startswith('['):
+            remaining = remaining[1:]  # Skip opening bracket
+            value_end = 0
+            # Find the closing bracket, handling escaped brackets
+            while value_end < len(remaining):
+                if remaining[value_end] == ']':
+                    # Count consecutive backslashes before this bracket
+                    backslash_count = 0
+                    pos = value_end - 1
+                    while pos >= 0 and remaining[pos] == '\\':
+                        backslash_count += 1
+                        pos -= 1
+                    # If even number of backslashes, bracket is not escaped
+                    # If odd number of backslashes, bracket is escaped
+                    if backslash_count % 2 == 0:
+                        break
+                value_end += 1
+            # Edge Case: Missing closing bracket
+            if value_end >= len(remaining):
+                raise ValueError("properties without delimiter")
+            value = remaining[:value_end]
+            values.append(_unescape_text(value))
+            remaining = remaining[value_end+1:]  # Skip closing bracket and move to next
+        properties[key] = values
+    return properties, remaining
+def _parse_subtree(content: str) -> tuple[str, str]:
+    """
+    Parse a subtree from its content string.
+    Args:
+        content: String starting with '('
+    Returns:
+        tuple: (subtree_content, remaining_content)
+    """
+    # Edge Case: Not starting with '('
+    if not content.startswith('('):
+        raise ValueError("tree missing")
+    balance = 0
+    i = 0
+    while i < len(content):
+        if content[i] == '(':
+            balance += 1
+        elif content[i] == ')':
+            balance -= 1
+            # Edge Case: Found matching closing parenthesis
+            if balance == 0:
+                return content[1:i], content[i+1:]
+        i += 1
+    # Edge Case: Unmatched parentheses
+    raise ValueError("tree missing")
+def _unescape_text(text: str) -> str:
+    """
+    Unescape SGF text according to SGF specification.
+    Args:
+        text: The escaped text
+    Returns:
+        str: The unescaped text
+    """
+    result = []
+    i = 0
+    while i < len(text):
+        if text[i] == '\\':
+            i += 1
+            # Edge Case: Backslash at end of string
+            if i >= len(text):
+                result.append('\\')
+                break
+            char = text[i]
+            # Handle newline removal after backslash
+            if char == '\n':
+                # Newline is removed if immediately after backslash
+                pass
+            # Convert other whitespace to space
+            elif char in ' \t\r':
+                result.append(' ')
+            else:
+                # Insert non-whitespace characters as-is
+                result.append(char)
+        else:
+            char = text[i]
+            # Convert whitespace (except newline) to space
+            if char in ' \t\r':
+                result.append(' ')
+            else:
+                result.append(char)
+        i += 1
+    return ''.join(result)
+# Handled Edge Cases: Empty input, missing opening parenthesis, missing closing parenthesis, empty tree, missing semicolon after opening parenthesis, property key not in uppercase, missing opening bracket for property value, missing closing bracket, not starting with '(', unmatched parentheses, backslash at end of string
+# Handled Edge Cases: Empty input, missing opening parenthesis, missing closing parenthesis, empty tree, missing semicolon after opening parenthesis
+# Handled Edge Cases: Property key not in uppercase, missing opening bracket for property value, missing closing bracket
+# Handled Edge Cases: Not starting with '(', unmatched parentheses
+# Handled Edge Cases: Backslash at end of string