| 26 | 26 | |
| 27 | 27 | |
| 28 | 28 | def parse(input_string: str) -> SgfTree: |
| 29 | | pass |
| 29 | """ |
| 30 | Parse an SGF string and return a tree structure of properties. |
| 31 | |
| 32 | Args: |
| 33 | input_string: A string in SGF format |
| 34 | |
| 35 | Returns: |
| 36 | SgfTree: The parsed SGF tree |
| 37 | |
| 38 | Raises: |
| 39 | ValueError: If the input is invalid according to SGF format rules |
| 40 | """ |
| 41 | # Edge Case: Empty input |
| 42 | if not input_string: |
| 43 | raise ValueError("tree missing") |
| 44 | |
| 45 | # Edge Case: Input doesn't start with '(' |
| 46 | if not input_string.startswith('('): |
| 47 | raise ValueError("tree missing") |
| 48 | |
| 49 | # Edge Case: Input doesn't end with ')' |
| 50 | if not input_string.endswith(')'): |
| 51 | raise ValueError("tree missing") |
| 52 | |
| 53 | # Remove the outer parentheses |
| 54 | content = input_string[1:-1] |
| 55 | |
| 56 | # Edge Case: Empty tree with no nodes |
| 57 | if not content: |
| 58 | raise ValueError("tree with no nodes") |
| 59 | |
| 60 | # Parse the tree |
| 61 | tree, _ = _parse_tree(content, 0) |
| 62 | return tree |
| 63 | |
| 64 | |
| 65 | def _parse_tree(content: str, index: int) -> tuple[SgfTree, int]: |
| 66 | """ |
| 67 | Parse a tree from the content string starting at index. |
| 68 | |
| 69 | Args: |
| 70 | content: The SGF content string |
| 71 | index: The starting index to parse from |
| 72 | |
| 73 | Returns: |
| 74 | tuple: A tuple containing the parsed SgfTree and the next index to parse from |
| 75 | """ |
| 76 | # Edge Case: Missing semicolon at start of node |
| 77 | if index >= len(content) or content[index] != ';': |
| 78 | raise ValueError("tree missing") |
| 79 | |
| 80 | index += 1 # Skip the semicolon |
| 81 | |
| 82 | # Parse the current node's properties |
| 83 | properties = {} |
| 84 | while index < len(content) and content[index] not in '();': |
| 85 | # Parse property key |
| 86 | key_start = index |
| 87 | while index < len(content) and content[index].isalpha() and content[index].isupper(): |
| 88 | index += 1 |
| 89 | |
| 90 | # Edge Case: Property key is not in uppercase |
| 91 | if index == key_start: |
| 92 | raise ValueError("property must be in uppercase") |
| 93 | |
| 94 | key = content[key_start:index] |
| 95 | |
| 96 | # Edge Case: Missing opening bracket for property value |
| 97 | if index >= len(content) or content[index] != '[': |
| 98 | raise ValueError("properties without delimiter") |
| 99 | |
| 100 | # Parse property values |
| 101 | values = [] |
| 102 | while index < len(content) and content[index] == '[': |
| 103 | index += 1 # Skip the opening bracket |
| 104 | value, index = _parse_value(content, index) |
| 105 | |
| 106 | # Edge Case: Missing closing bracket for property value |
| 107 | if index >= len(content) or content[index] != ']': |
| 108 | raise ValueError("properties without delimiter") |
| 109 | |
| 110 | index += 1 # Skip the closing bracket |
| 111 | values.append(value) |
| 112 | |
| 113 | properties[key] = values |
| 114 | |
| 115 | # Parse children |
| 116 | children = [] |
| 117 | while index < len(content) and content[index] == '(': |
| 118 | child, index = _parse_tree(content, index + 1) # Skip the opening parenthesis |
| 119 | |
| 120 | # Edge Case: Missing closing parenthesis for child |
| 121 | if index >= len(content) or content[index] != ')': |
| 122 | raise ValueError("tree missing") |
| 123 | |
| 124 | index += 1 # Skip the closing parenthesis |
| 125 | children.append(child) |
| 126 | |
| 127 | return SgfTree(properties, children), index |
| 128 | |
| 129 | |
| 130 | def _parse_value(content: str, index: int) -> tuple[str, int]: |
| 131 | """ |
| 132 | Parse a property value from the content string starting at index. |
| 133 | |
| 134 | Args: |
| 135 | content: The SGF content string |
| 136 | index: The starting index to parse from |
| 137 | |
| 138 | Returns: |
| 139 | tuple: A tuple containing the parsed value string and the next index to parse from |
| 140 | """ |
| 141 | result = [] |
| 142 | while index < len(content): |
| 143 | # Check for closing bracket (end of value) |
| 144 | if content[index] == ']': |
| 145 | break |
| 146 | |
| 147 | # Handle escape sequences |
| 148 | if content[index] == '\\': |
| 149 | index += 1 |
| 150 | if index >= len(content): |
| 151 | # Edge Case: Escape character at end of content |
| 152 | result.append('\\') |
| 153 | break |
| 154 | |
| 155 | char = content[index] |
| 156 | if char == '\n': |
| 157 | # Newline immediately after backslash is removed |
| 158 | pass # Do nothing, effectively removing the newline |
| 159 | elif char.isspace() and char != '\n': |
| 160 | # Whitespace other than newline is converted to space |
| 161 | result.append(' ') |
| 162 | else: |
| 163 | # Any character (including ] and other special chars) after \ is inserted as-is |
| 164 | result.append(char) |
| 165 | # Special case: if we just added an escaped ] and the next character is an uppercase letter, |
| 166 | # this might indicate the start of a new property |
| 167 | if char == ']' and index + 1 < len(content) and content[index + 1].isalpha() and content[index + 1].isupper(): |
| 168 | break |
| 169 | elif content[index] == '\n': |
| 170 | # Newlines remain as newlines unless escaped |
| 171 | result.append('\n') |
| 172 | elif content[index].isspace() and content[index] != '\n': |
| 173 | # All whitespace other than newline is converted to spaces |
| 174 | result.append(' ') |
| 175 | else: |
| 176 | # Regular character |
| 177 | result.append(content[index]) |
| 178 | index += 1 |
| 179 | |
| 180 | return ''.join(result), index |
| 181 | |
| 182 | # Handled Edge Cases: Empty input, Input doesn't start with '(', Input doesn't end with ')', Empty tree with no nodes, Missing semicolon at start of node, Property key is not in uppercase, Missing opening bracket for property value, Missing closing bracket for property value, Missing closing parenthesis for child, Escape character at end of content |