Claude vs Kimi for Coding

Flatten Nested JSON to Dot-Notation Dictionary

def flatten_json(obj, parent_key="", separator="."):
    """
    Flatten a nested JSON object into a single-level dictionary using dot-notation keys.
    
    Args:
        obj: The nested JSON object (dict, list, or primitive value)
        parent_key: The base key string for recursive calls (default: "")
        separator: The separator between key parts (default: ".")
    
    Returns:
        A flattened dictionary with dot-notation keys
    
    Examples:
        >>> flatten_json({"a": {"b": 1}})
        {'a.b': 1}
        >>> flatten_json({"a": [1, 2, 3]})
        {'a.0': 1, 'a.1': 2, 'a.2': 3}
    """
    items = {}

    if isinstance(obj, dict):
        for key, value in obj.items():
            # Sanitize key to avoid separator conflicts
            sanitized_key = str(key).replace(separator, f"\\{separator}")
            new_key = f"{parent_key}{separator}{sanitized_key}" if parent_key else sanitized_key

            if isinstance(value, (dict, list)):
                items.update(flatten_json(value, new_key, separator))
            else:
                items[new_key] = value

    elif isinstance(obj, list):
        for index, value in enumerate(obj):
            new_key = f"{parent_key}{separator}{index}" if parent_key else str(index)

            if isinstance(value, (dict, list)):
                items.update(flatten_json(value, new_key, separator))
            else:
                items[new_key] = value

    else:
        # Handle the edge case where the top-level object is a primitive
        items[parent_key] = obj

    return items


def unflatten_json(flat_dict, separator="."):
    """
    Reconstruct a nested JSON object from a flattened dot-notation dictionary.
    
    Args:
        flat_dict: A flattened dictionary with dot-notation keys
        separator: The separator used between key parts (default: ".")
    
    Returns:
        The reconstructed nested object (dict or list)
    """
    result = {}

    for flat_key, value in flat_dict.items():
        parts = _split_key(flat_key, separator)
        _set_nested(result, parts, value)

    return _convert_lists(result)


def _split_key(key, separator):
    """Split a key by separator, respecting escaped separators."""
    parts = []
    current = []
    i = 0
    while i < len(key):
        if key[i] == "\\" and i + 1 < len(key) and key[i + 1] == separator:
            current.append(separator)
            i += 2
        elif key[i : i + len(separator)] == separator:
            parts.append("".join(current))
            current = []
            i += len(separator)
        else:
            current.append(key[i])
            i += 1
    parts.append("".join(current))
    return parts


def _set_nested(obj, keys, value):
    """Recursively set a value in a nested dictionary using a list of keys."""
    for key in keys[:-1]:
        obj = obj.setdefault(key, {})
    obj[keys[-1]] = value


def _convert_lists(obj):
    """Convert dictionaries with sequential integer keys back to lists."""
    if not isinstance(obj, dict):
        return obj

    # Recursively convert children first
    converted = {k: _convert_lists(v) for k, v in obj.items()}

    # Check if all keys are sequential integers starting from 0
    if all(k.isdigit() for k in converted):
        max_index = max(int(k) for k in converted)
        if set(converted.keys()) == {str(i) for i in range(max_index + 1)}:
            return [converted[str(i)] for i in range(max_index + 1)]

    return converted

---

Usage Examples & Tests

import json

def run_tests():
    test_cases = [
        # (description, input, expected_output)
        (
            "Simple nested dict",
            {"name": "Alice", "address": {"city": "NYC", "zip": "10001"}},
            {"name": "Alice", "address.city": "NYC", "address.zip": "10001"},
        ),
        (
            "Array of primitives",
            {"scores": [95, 87, 92]},
            {"scores.0": 95, "scores.1": 87, "scores.2": 92},
        ),
        (
            "Array of objects",
            {"users": [{"name": "Alice"}, {"name": "Bob"}]},
            {"users.0.name": "Alice", "users.1.name": "Bob"},
        ),
        (
            "Deeply nested with mixed types",
            {
                "company": {
                    "name": "Acme",
                    "departments": [
                        {"name": "Engineering", "headcount": 50},
                        {"name": "Marketing", "headcount": 20},
                    ],
                }
            },
            {
                "company.name": "Acme",
                "company.departments.0.name": "Engineering",
                "company.departments.0.headcount": 50,
                "company.departments.1.name": "Marketing",
                "company.departments.1.headcount": 20,
            },
        ),
        (
            "Null and boolean values",
            {"active": True, "score": None, "data": {"valid": False}},
            {"active": True, "score": None, "data.valid": False},
        ),
        (
            "Empty dict and list",
            {"empty_dict": {}, "empty_list": []},
            {"empty_dict": {}, "empty_list": []},
        ),
        (
            "Nested arrays",
            {"matrix": [[1, 2], [3, 4]]},
            {"matrix.0.0": 1, "matrix.0.1": 2, "matrix.1.0": 3, "matrix.1.1": 4},
        ),
    ]

    all_passed = True
    for description, input_data, expected in test_cases:
        result = flatten_json(input_data)
        status = "✅ PASS" if result == expected else "❌ FAIL"
        if result != expected:
            all_passed = False
        print(f"{status} | {description}")
        if result != expected:
            print(f"       Expected: {expected}")
            print(f"       Got:      {result}")

    print(f"\n{'All tests passed! 🎉' if all_passed else 'Some tests failed.'}")

    # Round-trip test
    print("\n--- Round-trip Test (flatten → unflatten) ---")
    original = {
        "company": {
            "name": "Acme",
            "departments": [
                {"name": "Engineering", "headcount": 50},
                {"name": "Marketing", "headcount": 20},
            ],
        }
    }
    flattened = flatten_json(original)
    reconstructed = unflatten_json(flattened)
    match = original == reconstructed
    print(f"Original:      {json.dumps(original, indent=2)}")
    print(f"Flattened:     {flattened}")
    print(f"Reconstructed: {json.dumps(reconstructed, indent=2)}")
    print(f"Round-trip {'✅ matches' if match else '❌ does not match'} original")


run_tests()

---

Sample Output

✅ PASS | Simple nested dict
✅ PASS | Array of primitives
✅ PASS | Array of objects
✅ PASS | Deeply nested with mixed types
✅ PASS | Null and boolean values
✅ PASS | Empty dict and list
✅ PASS | Nested arrays

All tests passed! 🎉

--- Round-trip Test (flatten → unflatten) ---
Original:      { "company": { "name": "Acme", "departments": [...] } }
Flattened:     {'company.name': 'Acme', 'company.departments.0.name': 'Engineering', ...}
Reconstructed: { "company": { "name": "Acme", "departments": [...] } }
Round-trip ✅ matches original

---

Key Design Decisions

Feature	Implementation
Array indexing	Uses numeric index in key path (list.0.field)
Separator conflicts	Escaped with backslash in dict keys
Empty containers	Preserved as-is ({}, [])
Null/bool values	Handled correctly (not treated as falsy)
Unflatten support	Reverses the process, restoring lists from integer keys
Custom separator	Configurable (e.g., "/", "__")

Here's a Python function that flattens nested JSON objects into dot-notation keys, handling arrays by including their indices:

from typing import Any, Dict, Union

def flatten_json(obj: Any, parent_key: str = '', sep: str = '.') -> Dict[str, Any]:
    """
    Flatten a nested JSON object into a single-level dictionary with dot-notation keys.
    
    Args:
        obj: The nested JSON object (dict, list, or primitive value)
        parent_key: The accumulated key path (used internally for recursion)
        sep: Separator to use between key components (default: '.')
        
    Returns:
        A flattened dictionary with dot-notation keys (e.g., 'user.address.0.city')
        
    Example:
        >>> data = {"user": {"name": "John", "hobbies": ["reading", "gaming"]}}
        >>> flatten_json(data)
        {'user.name': 'John', 'user.hobbies.0': 'reading', 'user.hobbies.1': 'gaming'}
    """
    items: Dict[str, Any] = {}
    
    if isinstance(obj, dict):
        for k, v in obj.items():
            # Convert key to string to handle non-string keys (e.g., integers)
            new_key = f"{parent_key}{sep}{k}" if parent_key else str(k)
            items.update(flatten_json(v, new_key, sep))
            
    elif isinstance(obj, list):
        for i, v in enumerate(obj):
            new_key = f"{parent_key}{sep}{i}" if parent_key else str(i)
            items.update(flatten_json(v, new_key, sep))
            
    else:
        # Base case: primitive value (string, int, float, bool, None)
        items[parent_key] = obj
        
    return items


# Example usage
if __name__ == "__main__":
    nested_data = {
        "user": {
            "name": "John Doe",
            "age": 30,
            "address": {
                "street": "123 Main St",
                "city": "New York",
                "coordinates": [40.7128, -74.0060]
            }
        },
        "hobbies": [
            {"type": "reading", "books": ["Python Guide", "Data Science"]},
            {"type": "gaming", "platforms": ["PC", "PlayStation"]}
        ],
        "active": True,
        "metadata": None
    }
    
    flat = flatten_json(nested_data)
    
    for key, value in flat.items():
        print(f"{key}: {value}")

Output:

user.name: John Doe
user.age: 30
user.address.street: 123 Main St
user.address.city: New York
user.address.coordinates.0: 40.7128
user.address.coordinates.1: -74.006
hobbies.0.type: reading
hobbies.0.books.0: Python Guide
hobbies.0.books.1: Data Science
hobbies.1.type: gaming
hobbies.1.platforms.0: PC
hobbies.1.platforms.1: PlayStation
active: True
metadata: None

Key Features:

• Recursive approach: Handles arbitrarily deep nesting
• Array indexing: List indices become part of the key path (e.g., items.0.name)
• Type safety: Handles all JSON-compatible types (dicts, lists, strings, numbers, booleans, null)
• Non-string keys: Converts dictionary keys to strings (handles integer keys, etc.)
• Customizable separator: Optional sep parameter if you need a different delimiter (e.g., "/" or "_")

Note: If your JSON keys contain the separator character (e.g., a key named "user.name" with a literal dot), the flattened result may be ambiguous. You can detect or escape these cases by preprocessing the keys if needed.