Initial Query

Write me a python function called fix_json that fixes broken JSON objects, and returns the parsed object. I'll pass the JSON object as a string and it should fix: - Incorect parenthesis, e.g., {"a": (5, 4)} -> {"a": [5, 4]} - Incorrect single quotes, e.g., {'a': 5} -> {"a": 5} - False/True -> false/true Make sure not to break data inside strings! So if there's a True or a ( inside a string keep them the way they are. Also don't break quoted strings

LLM Generation

Query

Write me a python function called fix_json that fixes broken JSON objects, and returns the parsed object. I'll pass the JSON object as a string and it should fix: - Incorect parenthesis, e.g., {"a": (5, 4)} -> {"a": [5, 4]} - Incorrect single quotes, e.g., {'a': 5} -> {"a": 5} - False/True -> false/true Make sure not to break data inside strings! So if there's a True or a ( inside a string keep them the way they are. Also don't break quoted strings

Output

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
import json
import re

def fix_json(json_string: str) -> object:
    """
    Attempts to fix common issues in non-standard JSON strings and parse it.

    Fixes include:
    - Replacing Python-style tuples (using parentheses) with JSON arrays (using square brackets).
    - Replacing single quotes used for strings or keys with double quotes.
    - Replacing Python-style booleans (True/False) with JSON booleans (true/false).

    These fixes are applied carefully to avoid modifying content within strings.

    Args:
        json_string: The potentially broken JSON string.

    Returns:
        The parsed Python object if successful.

    Raises:
        json.JSONDecodeError: If the string cannot be parsed even after attempting fixes.
        ValueError: If the input is fundamentally not JSON-like after fixes.
    """
    if not isinstance(json_string, str):
        raise TypeError("Input must be a string.")

    # Define regex to find strings (double or single quoted, handling escapes)
    # This helps us isolate parts of the string that are *not* inside quotes.
    # Group 1: Double-quoted string
    # Group 2: Single-quoted string
    string_regex = r'(" (?:\\.|[^"\\])* ") | (\' (?:\\.|[^ \'\\])* \')'

    # Use re.split to break the string by quoted sections, keeping the delimiters
    # The result is a list alternating between non-string parts and string parts.
    parts = re.split(f'({string_regex})', json_string, flags=re.VERBOSE)

    fixed_parts = []
    for part in parts:
        if part is None or part == '':
            continue

        # Check if the part is a captured string (starts/ends with quotes)
        is_double_quoted = part.startswith('"') and part.endswith('"')
        is_single_quoted = part.startswith("'") and part.endswith("'")

        if is_double_quoted:
            # Keep double-quoted strings as is
            fixed_parts.append(part)
        elif is_single_quoted:
            # Convert single-quoted strings to double-quoted strings
            # Ensure internal single quotes are handled correctly (they should already be escaped if needed)
            # Just replace the outer quotes
            fixed_parts.append('"' + part[1:-1] + '"')
        else:
            # This part is *not* a string literal, apply other fixes
            # 1. Fix single quotes used for keys/structure -> double quotes
            part_fixed_quotes = part.replace("'", '"')
            # 2. Fix parentheses -> square brackets
            part_fixed_brackets = part_fixed_quotes.replace("(", "[").replace(")", "]")
            # 3. Fix Python booleans -> JSON booleans (use word boundaries \b)
            part_fixed_bools = re.sub(r'\bTrue\b', 'true', part_fixed_brackets)
            part_fixed_bools = re.sub(r'\bFalse\b', 'false', part_fixed_bools)
            fixed_parts.append(part_fixed_bools)

    fixed_json_string = "".join(fixed_parts)

    # Attempt to parse the fixed string
    try:
        return json.loads(fixed_json_string)
    except json.JSONDecodeError as e:
        # If parsing fails, raise the error with context
        # You could add more sophisticated error handling or retry logic here if needed
        # print(f"DEBUG: Attempted fix resulted in: {fixed_json_string}") # Uncomment for debugging
        raise json.JSONDecodeError(
            f"Failed to parse JSON even after fixes: {e.msg}",
            fixed_json_string, # Pass the modified string to the error
            e.pos
        ) from e
    except Exception as e:
        # Catch other potential errors during processing
        raise ValueError(f"An unexpected error occurred during JSON fixing: {e}") from e

# --- Examples ---

# Example 1: Incorrect Parentheses
json_str1 = '{"a": (5, 4), "b": "A string with (parentheses)"}'
print(f"Original 1: {json_str1}")
try:
    parsed1 = fix_json(json_str1)
    print(f"Fixed & Parsed 1: {parsed1}")
    print(f"Type of parsed1['a']: {type(parsed1['a'])}") # Should be list
except Exception as e:
    print(f"Error 1: {e}")
print("-" * 20)

# Example 2: Incorrect Single Quotes
json_str2 = "{'a': 5, 'b': 'it\\'s a string', 'c': \"double quoted\"}"
print(f"Original 2: {json_str2}")
try:
    parsed2 = fix_json(json_str2)
    print(f"Fixed & Parsed 2: {parsed2}")
except Exception as e:
    print(f"Error 2: {e}")
print("-" * 20)

# Example 3: Incorrect Booleans
json_str3 = '{"isValid": True, "isInvalid": False, "message": "True story"}'
print(f"Original 3: {json_str3}")
try:
    parsed3 = fix_json(json_str3)
    print(f"Fixed & Parsed 3: {parsed3}")
    print(f"Type of parsed3['isValid']: {type(parsed3['isValid'])}") # Should be bool
except Exception as e:
    print(f"Error 3: {e}")
print("-" * 20)

# Example 4: Combination of issues
json_str4 = "{'data': (1, True, 'hello'), 'status': False, 'info': 'Keep (this) and True/False as is'}"
print(f"Original 4: {json_str4}")
try:
    parsed4 = fix_json(json_str4)
    print(f"Fixed & Parsed 4: {parsed4}")
except Exception as e:
    print(f"Error 4: {e}")
print("-" * 20)

# Example 5: Already valid JSON
json_str5 = '{"a": [1, 2], "b": "hello", "c": true}'
print(f"Original 5: {json_str5}")
try:
    parsed5 = fix_json(json_str5)
    print(f"Fixed & Parsed 5: {parsed5}")
except Exception as e:
    print(f"Error 5: {e}")
print("-" * 20)

# Example 6: Invalid JSON structure (trailing comma - might not be fixed by this func)
json_str6 = '{"a": 1,}'
print(f"Original 6: {json_str6}")
try:
    parsed6 = fix_json(json_str6)
    print(f"Fixed & Parsed 6: {parsed6}")
except Exception as e:
    print(f"Error 6: {e}") # Expected to fail parsing
print("-" * 20)

# Example 7: Empty String (should fail)
json_str7 = ''
print(f"Original 7: {json_str7}")
try:
    parsed7 = fix_json(json_str7)
    print(f"Fixed & Parsed 7: {parsed7}")
except Exception as e:
    print(f"Error 7: {e}") # Expected to fail parsing
print("-" * 20)

# Example 8: Non-string input
json_str8 = {"a": 1}
print(f"Original 8: {json_str8}")
try:
    parsed8 = fix_json(json_str8)
    print(f"Fixed & Parsed 8: {parsed8}")
except Exception as e:
    print(f"Error 8: {e}") # Expected TypeError
print("-" * 20)
**Explanation:** 1. **Import `json` and `re`:** We need the `json` module for parsing and the `re` module for regular expressions. 2. **Define `fix_json` function:** Takes `json_string` as input and includes type hinting and a docstring. 3. **Input Type Check:** Ensures the input is actually a string. 4. **String Regex:** * `string_regex` is defined to match either double-quoted strings (`"..."`) or single-quoted strings (`'...'`). * `(?:\\.|[^"\\])*` is the core part for matching content inside quotes: * `\\.`: Matches any escaped character (e.g., `\"`, `\\`, `\'`). * `[^"\\]`: Matches any character that is *not* a double quote (`"`) or a backslash (`\`). * `( ... )*`: Matches the preceding group zero or more times. * The pattern is similar for single quotes (`'`). * The `|` separates the double-quote pattern and the single-quote pattern. * `re.VERBOSE` allows for whitespace and comments in the regex string for readability (though not heavily used here). 5. **`re.split()`:** * This is the key step. We split the `json_string` using the `string_regex` as the delimiter. * Crucially, we put parentheses `()` around the entire `string_regex` pattern passed to `split`. This tells `re.split` to *keep* the delimiters (the strings themselves) in the resulting list. * The output `parts` list will look something like `[non_string_part, string_part, non_string_part, string_part, ...]`. Some parts might be empty strings or `None`, which we handle. 6. **Iterate and Fix Parts:** * We loop through the `parts` list. * We skip any `None` or empty parts. * **Identify Strings:** We check if a `part` starts and ends with `"` or `'`. * **Process Strings:** * If it's double-quoted, we append it to `fixed_parts` unchanged. * If it's single-quoted, we replace the outer single quotes with double quotes (`'"' + part[1:-1] + '"'`) and append the result. The content *inside* the string remains untouched. * **Process Non-Strings:** If the `part` is *not* identified as a string literal: * We perform the required replacements: * `part.replace("'", '"')`: Replaces structural single quotes with double quotes. * `.replace("(", "[").replace(")", "]")`: Replaces structural parentheses with square brackets. * `re.sub(r'\bTrue\b', 'true', ...)`: Replaces the whole word `True` with `true`. `\b` ensures we don't replace `True` if it's part of another word (e.g., `IsTrue`). * `re.sub(r'\bFalse\b', 'false', ...)`: Similarly replaces `False` with `false`. * The modified non-string part is appended to `fixed_parts`. 7. **Join and Parse:** * `"".join(fixed_parts)` reconstructs the potentially fixed JSON string. * `json.loads()` attempts to parse this reconstructed string. 8. **Error Handling:** * A `try...except json.JSONDecodeError` block catches parsing errors. If parsing fails even after the fixes, the original error is re-raised, but importantly, it includes the *modified* string in the error message, which can be helpful for debugging. * A general `except Exception` catches other potential errors during the fixing process itself. This approach effectively isolates string literals and applies the structural fixes only to the parts of the input string that are *not* inside quotes, satisfying all the requirements.

Extract Code

I extracted the following code from that output: 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
import json
import re

def fix_json(json_string: str) -> object:
    """
    Attempts to fix common issues in non-standard JSON strings and parse it.

    Fixes include:
    - Replacing Python-style tuples (using parentheses) with JSON arrays (using square brackets).
    - Replacing single quotes used for strings or keys with double quotes.
    - Replacing Python-style booleans (True/False) with JSON booleans (true/false).

    These fixes are applied carefully to avoid modifying content within strings.

    Args:
        json_string: The potentially broken JSON string.

    Returns:
        The parsed Python object if successful.

    Raises:
        json.JSONDecodeError: If the string cannot be parsed even after attempting fixes.
        ValueError: If the input is fundamentally not JSON-like after fixes.
    """
    if not isinstance(json_string, str):
        raise TypeError("Input must be a string.")

    # Define regex to find strings (double or single quoted, handling escapes)
    # This helps us isolate parts of the string that are *not* inside quotes.
    # Group 1: Double-quoted string
    # Group 2: Single-quoted string
    string_regex = r'(" (?:\\.|[^"\\])* ") | (\' (?:\\.|[^ \'\\])* \')'

    # Use re.split to break the string by quoted sections, keeping the delimiters
    # The result is a list alternating between non-string parts and string parts.
    parts = re.split(f'({string_regex})', json_string, flags=re.VERBOSE)

    fixed_parts = []
    for part in parts:
        if part is None or part == '':
            continue

        # Check if the part is a captured string (starts/ends with quotes)
        is_double_quoted = part.startswith('"') and part.endswith('"')
        is_single_quoted = part.startswith("'") and part.endswith("'")

        if is_double_quoted:
            # Keep double-quoted strings as is
            fixed_parts.append(part)
        elif is_single_quoted:
            # Convert single-quoted strings to double-quoted strings
            # Ensure internal single quotes are handled correctly (they should already be escaped if needed)
            # Just replace the outer quotes
            fixed_parts.append('"' + part[1:-1] + '"')
        else:
            # This part is *not* a string literal, apply other fixes
            # 1. Fix single quotes used for keys/structure -> double quotes
            part_fixed_quotes = part.replace("'", '"')
            # 2. Fix parentheses -> square brackets
            part_fixed_brackets = part_fixed_quotes.replace("(", "[").replace(")", "]")
            # 3. Fix Python booleans -> JSON booleans (use word boundaries \b)
            part_fixed_bools = re.sub(r'\bTrue\b', 'true', part_fixed_brackets)
            part_fixed_bools = re.sub(r'\bFalse\b', 'false', part_fixed_bools)
            fixed_parts.append(part_fixed_bools)

    fixed_json_string = "".join(fixed_parts)

    # Attempt to parse the fixed string
    try:
        return json.loads(fixed_json_string)
    except json.JSONDecodeError as e:
        # If parsing fails, raise the error with context
        # You could add more sophisticated error handling or retry logic here if needed
        # print(f"DEBUG: Attempted fix resulted in: {fixed_json_string}") # Uncomment for debugging
        raise json.JSONDecodeError(
            f"Failed to parse JSON even after fixes: {e.msg}",
            fixed_json_string, # Pass the modified string to the error
            e.pos
        ) from e
    except Exception as e:
        # Catch other potential errors during processing
        raise ValueError(f"An unexpected error occurred during JSON fixing: {e}") from e

# --- Examples ---

# Example 1: Incorrect Parentheses
json_str1 = '{"a": (5, 4), "b": "A string with (parentheses)"}'
print(f"Original 1: {json_str1}")
try:
    parsed1 = fix_json(json_str1)
    print(f"Fixed & Parsed 1: {parsed1}")
    print(f"Type of parsed1['a']: {type(parsed1['a'])}") # Should be list
except Exception as e:
    print(f"Error 1: {e}")
print("-" * 20)

# Example 2: Incorrect Single Quotes
json_str2 = "{'a': 5, 'b': 'it\\'s a string', 'c': \"double quoted\"}"
print(f"Original 2: {json_str2}")
try:
    parsed2 = fix_json(json_str2)
    print(f"Fixed & Parsed 2: {parsed2}")
except Exception as e:
    print(f"Error 2: {e}")
print("-" * 20)

# Example 3: Incorrect Booleans
json_str3 = '{"isValid": True, "isInvalid": False, "message": "True story"}'
print(f"Original 3: {json_str3}")
try:
    parsed3 = fix_json(json_str3)
    print(f"Fixed & Parsed 3: {parsed3}")
    print(f"Type of parsed3['isValid']: {type(parsed3['isValid'])}") # Should be bool
except Exception as e:
    print(f"Error 3: {e}")
print("-" * 20)

# Example 4: Combination of issues
json_str4 = "{'data': (1, True, 'hello'), 'status': False, 'info': 'Keep (this) and True/False as is'}"
print(f"Original 4: {json_str4}")
try:
    parsed4 = fix_json(json_str4)
    print(f"Fixed & Parsed 4: {parsed4}")
except Exception as e:
    print(f"Error 4: {e}")
print("-" * 20)

# Example 5: Already valid JSON
json_str5 = '{"a": [1, 2], "b": "hello", "c": true}'
print(f"Original 5: {json_str5}")
try:
    parsed5 = fix_json(json_str5)
    print(f"Fixed & Parsed 5: {parsed5}")
except Exception as e:
    print(f"Error 5: {e}")
print("-" * 20)

# Example 6: Invalid JSON structure (trailing comma - might not be fixed by this func)
json_str6 = '{"a": 1,}'
print(f"Original 6: {json_str6}")
try:
    parsed6 = fix_json(json_str6)
    print(f"Fixed & Parsed 6: {parsed6}")
except Exception as e:
    print(f"Error 6: {e}") # Expected to fail parsing
print("-" * 20)

# Example 7: Empty String (should fail)
json_str7 = ''
print(f"Original 7: {json_str7}")
try:
    parsed7 = fix_json(json_str7)
    print(f"Fixed & Parsed 7: {parsed7}")
except Exception as e:
    print(f"Error 7: {e}") # Expected to fail parsing
print("-" * 20)

# Example 8: Non-string input
json_str8 = {"a": 1}
print(f"Original 8: {json_str8}")
try:
    parsed8 = fix_json(json_str8)
    print(f"Fixed & Parsed 8: {parsed8}")
except Exception as e:
    print(f"Error 8: {e}") # Expected TypeError
print("-" * 20)

Run Code Interpreter

Running the following program: 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
import json
import re

def fix_json(json_string: str) -> object:
    """
    Attempts to fix common issues in non-standard JSON strings and parse it.

    Fixes include:
    - Replacing Python-style tuples (using parentheses) with JSON arrays (using square brackets).
    - Replacing single quotes used for strings or keys with double quotes.
    - Replacing Python-style booleans (True/False) with JSON booleans (true/false).

    These fixes are applied carefully to avoid modifying content within strings.

    Args:
        json_string: The potentially broken JSON string.

    Returns:
        The parsed Python object if successful.

    Raises:
        json.JSONDecodeError: If the string cannot be parsed even after attempting fixes.
        ValueError: If the input is fundamentally not JSON-like after fixes.
    """
    if not isinstance(json_string, str):
        raise TypeError("Input must be a string.")

    # Define regex to find strings (double or single quoted, handling escapes)
    # This helps us isolate parts of the string that are *not* inside quotes.
    # Group 1: Double-quoted string
    # Group 2: Single-quoted string
    string_regex = r'(" (?:\\.|[^"\\])* ") | (\' (?:\\.|[^ \'\\])* \')'

    # Use re.split to break the string by quoted sections, keeping the delimiters
    # The result is a list alternating between non-string parts and string parts.
    parts = re.split(f'({string_regex})', json_string, flags=re.VERBOSE)

    fixed_parts = []
    for part in parts:
        if part is None or part == '':
            continue

        # Check if the part is a captured string (starts/ends with quotes)
        is_double_quoted = part.startswith('"') and part.endswith('"')
        is_single_quoted = part.startswith("'") and part.endswith("'")

        if is_double_quoted:
            # Keep double-quoted strings as is
            fixed_parts.append(part)
        elif is_single_quoted:
            # Convert single-quoted strings to double-quoted strings
            # Ensure internal single quotes are handled correctly (they should already be escaped if needed)
            # Just replace the outer quotes
            fixed_parts.append('"' + part[1:-1] + '"')
        else:
            # This part is *not* a string literal, apply other fixes
            # 1. Fix single quotes used for keys/structure -> double quotes
            part_fixed_quotes = part.replace("'", '"')
            # 2. Fix parentheses -> square brackets
            part_fixed_brackets = part_fixed_quotes.replace("(", "[").replace(")", "]")
            # 3. Fix Python booleans -> JSON booleans (use word boundaries \b)
            part_fixed_bools = re.sub(r'\bTrue\b', 'true', part_fixed_brackets)
            part_fixed_bools = re.sub(r'\bFalse\b', 'false', part_fixed_bools)
            fixed_parts.append(part_fixed_bools)

    fixed_json_string = "".join(fixed_parts)

    # Attempt to parse the fixed string
    try:
        return json.loads(fixed_json_string)
    except json.JSONDecodeError as e:
        # If parsing fails, raise the error with context
        # You could add more sophisticated error handling or retry logic here if needed
        # print(f"DEBUG: Attempted fix resulted in: {fixed_json_string}") # Uncomment for debugging
        raise json.JSONDecodeError(
            f"Failed to parse JSON even after fixes: {e.msg}",
            fixed_json_string, # Pass the modified string to the error
            e.pos
        ) from e
    except Exception as e:
        # Catch other potential errors during processing
        raise ValueError(f"An unexpected error occurred during JSON fixing: {e}") from e

# --- Examples ---

# Example 1: Incorrect Parentheses
json_str1 = '{"a": (5, 4), "b": "A string with (parentheses)"}'
print(f"Original 1: {json_str1}")
try:
    parsed1 = fix_json(json_str1)
    print(f"Fixed & Parsed 1: {parsed1}")
    print(f"Type of parsed1['a']: {type(parsed1['a'])}") # Should be list
except Exception as e:
    print(f"Error 1: {e}")
print("-" * 20)

# Example 2: Incorrect Single Quotes
json_str2 = "{'a': 5, 'b': 'it\\'s a string', 'c': \"double quoted\"}"
print(f"Original 2: {json_str2}")
try:
    parsed2 = fix_json(json_str2)
    print(f"Fixed & Parsed 2: {parsed2}")
except Exception as e:
    print(f"Error 2: {e}")
print("-" * 20)

# Example 3: Incorrect Booleans
json_str3 = '{"isValid": True, "isInvalid": False, "message": "True story"}'
print(f"Original 3: {json_str3}")
try:
    parsed3 = fix_json(json_str3)
    print(f"Fixed & Parsed 3: {parsed3}")
    print(f"Type of parsed3['isValid']: {type(parsed3['isValid'])}") # Should be bool
except Exception as e:
    print(f"Error 3: {e}")
print("-" * 20)

# Example 4: Combination of issues
json_str4 = "{'data': (1, True, 'hello'), 'status': False, 'info': 'Keep (this) and True/False as is'}"
print(f"Original 4: {json_str4}")
try:
    parsed4 = fix_json(json_str4)
    print(f"Fixed & Parsed 4: {parsed4}")
except Exception as e:
    print(f"Error 4: {e}")
print("-" * 20)

# Example 5: Already valid JSON
json_str5 = '{"a": [1, 2], "b": "hello", "c": true}'
print(f"Original 5: {json_str5}")
try:
    parsed5 = fix_json(json_str5)
    print(f"Fixed & Parsed 5: {parsed5}")
except Exception as e:
    print(f"Error 5: {e}")
print("-" * 20)

# Example 6: Invalid JSON structure (trailing comma - might not be fixed by this func)
json_str6 = '{"a": 1,}'
print(f"Original 6: {json_str6}")
try:
    parsed6 = fix_json(json_str6)
    print(f"Fixed & Parsed 6: {parsed6}")
except Exception as e:
    print(f"Error 6: {e}") # Expected to fail parsing
print("-" * 20)

# Example 7: Empty String (should fail)
json_str7 = ''
print(f"Original 7: {json_str7}")
try:
    parsed7 = fix_json(json_str7)
    print(f"Fixed & Parsed 7: {parsed7}")
except Exception as e:
    print(f"Error 7: {e}") # Expected to fail parsing
print("-" * 20)

# Example 8: Non-string input
json_str8 = {"a": 1}
print(f"Original 8: {json_str8}")
try:
    parsed8 = fix_json(json_str8)
    print(f"Fixed & Parsed 8: {parsed8}")
except Exception as e:
    print(f"Error 8: {e}") # Expected TypeError
print("-" * 20)





answer = fix_json('''{"a": 5, "b": [3, 4]}''')
expected = {"a": 5, "b": [3, 4]}
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'

answer = fix_json('''{'a': 5.0, 'b': (True, 4)}''')
expected = {"a": 5.0, "b": [True, 4]}
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'

answer = fix_json('''{'True': False, 'b()': (3, 4), "c'": []}''')
expected = {"True": False, "b()": [3, 4], "c'": []}
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'
print('All tests passed')
And got the output: 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
Original 1: {"a": (5, 4), "b": "A string with (parentheses)"}
Error 1: Failed to parse JSON even after fixes: Expecting ':' delimiter: line 1 column 5 (char 4)</p>
<hr />
<p>Original 2: {'a': 5, 'b': 'it\'s a string', 'c': "double quoted"}
Error 2: Failed to parse JSON even after fixes: Expecting ':' delimiter: line 1 column 5 (char 4)</p>
<hr />
<p>Original 3: {"isValid": True, "isInvalid": False, "message": "True story"}
Error 3: Failed to parse JSON even after fixes: Expecting ':' delimiter: line 1 column 11 (char 10)</p>
<hr />
<p>Original 4: {'data': (1, True, 'hello'), 'status': False, 'info': 'Keep (this) and True/False as is'}
Error 4: Failed to parse JSON even after fixes: Expecting ':' delimiter: line 1 column 8 (char 7)</p>
<hr />
<p>Original 5: {"a": [1, 2], "b": "hello", "c": true}
Error 5: Failed to parse JSON even after fixes: Expecting ':' delimiter: line 1 column 5 (char 4)</p>
<hr />
<p>Original 6: {"a": 1,}
Error 6: Failed to parse JSON even after fixes: Expecting ':' delimiter: line 1 column 5 (char 4)</p>
<hr />
<p>Original 7: 
Error 7: Failed to parse JSON even after fixes: Expecting value: line 1 column 1 (char 0)</p>
<hr />
<p>Original 8: {'a': 1}
Error 8: Input must be a string.</p>
<hr />
<p>Traceback (most recent call last):
  File "/usr/src/app/main.py", line 71, in fix_json
    return json.loads(fixed_json_string)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/lib/python3.12/json/<strong>init</strong>.py", line 346, in loads
    return _default_decoder.decode(s)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/lib/python3.12/json/decoder.py", line 337, in decode
    obj, end = self.raw_decode(s, idx=_w(s, 0).end())
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/lib/python3.12/json/decoder.py", line 353, in raw_decode
    obj, end = self.scan_once(s, idx)
               ^^^^^^^^^^^^^^^^^^^^^^
json.decoder.JSONDecodeError: Expecting ':' delimiter: line 1 column 5 (char 4)
The above exception was the direct cause of the following exception:
Traceback (most recent call last):
  File "/usr/src/app/main.py", line 173, in <module>
    answer = fix_json('''{"a": 5, "b": [3, 4]}''')
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/src/app/main.py", line 76, in fix_json
    raise json.JSONDecodeError(
json.decoder.JSONDecodeError: Failed to parse JSON even after fixes: Expecting ':' delimiter: line 1 column 5 (char 4)

Substring Evaluation

Testing if the previous output contains the string All tests passed: False