ChatGPT vs Claude for Coding

def flatten_json(obj, parent_key="", sep="."):
    flat = {}

    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else str(key)
            flat.update(flatten_json(value, new_key, sep))
    elif isinstance(obj, list):
        for i, value in enumerate(obj):
            new_key = f"{parent_key}{sep}{i}" if parent_key else str(i)
            flat.update(flatten_json(value, new_key, sep))
    else:
        flat[parent_key] = obj

    return flat

Example:

data = {
    "user": {
        "name": "Alice",
        "address": {
            "city": "New York"
        },
        "phones": ["123-456", "987-654"]
    }
}

print(flatten_json(data))

Output:

{
    'user.name': 'Alice',
    'user.address.city': 'New York',
    'user.phones.0': '123-456',
    'user.phones.1': '987-654'
}

If you want, I can also provide:

• a version that preserves empty dicts/lists
• a non-recursive version
• an unflatten function to reverse the process

Flattening Nested JSON with Dot-Notation Keys

from typing import Any


def flatten_json(
    data: Any,
    parent_key: str = "",
    separator: str = ".",
    array_format: str = "index",  # "index" → arr.0.x | "bracket" → arr[0].x
) -> dict[str, Any]:
    """
    Flatten a nested JSON object into a single-level dictionary with dot-notation keys.

    Args:
        data:         The input data (dict, list, or scalar value).
        parent_key:   The prefix to prepend to each key (used during recursion).
        separator:    The separator between nested keys (default: ".").
        array_format: How to represent array indices.
                      "index"   → "array.0.key"
                      "bracket" → "array[0].key"

    Returns:
        A flat dictionary where every key encodes the full path to a leaf value.

    Raises:
        TypeError: If `array_format` is not "index" or "bracket".
        ValueError: If `separator` is empty.
    """
    if separator == "":
        raise ValueError("separator must be a non-empty string")
    if array_format not in ("index", "bracket"):
        raise TypeError(f"array_format must be 'index' or 'bracket', got {array_format!r}")

    items: dict[str, Any] = {}

    def _build_key(parent: str, child: str | int, is_index: bool = False) -> str:
        """Construct the next key segment based on the chosen array format."""
        if not parent:
            return str(child)

        if is_index and array_format == "bracket":
            return f"{parent}[{child}]"

        return f"{parent}{separator}{child}"

    def _flatten(node: Any, key: str) -> None:
        """Recursively walk *node*, accumulating leaf values in *items*."""
        if isinstance(node, dict):
            if not node:                            # preserve empty dicts
                items[key] = {}
                return
            for field, value in node.items():
                _flatten(value, _build_key(key, field))

        elif isinstance(node, list):
            if not node:                            # preserve empty lists
                items[key] = []
                return
            for idx, value in enumerate(node):
                _flatten(value, _build_key(key, idx, is_index=True))

        else:                                       # scalar leaf (str, int, float, bool, None)
            items[key] = node

    _flatten(data, parent_key)
    return items


# ──────────────────────────────────────────────
# Inverse: rebuild the original structure
# ──────────────────────────────────────────────
def unflatten_json(
    flat: dict[str, Any],
    separator: str = ".",
) -> Any:
    """
    Reconstruct a nested structure from a flat dot-notation dictionary.

    Numeric-only key segments are treated as list indices; everything else
    becomes a dict key.

    Args:
        flat:      A flat dictionary produced by `flatten_json`.
        separator: The separator used when the data was flattened.

    Returns:
        The reconstructed nested dict / list / scalar.
    """
    if not flat:
        return {}

    root: dict | list = {}

    def _set_nested(container: dict | list, parts: list[str], value: Any) -> None:
        for i, part in enumerate(parts[:-1]):
            next_part = parts[i + 1]
            next_is_list = next_part.isdigit()

            if isinstance(container, list):
                idx = int(part)
                # Extend the list if needed
                while len(container) <= idx:
                    container.append(None)
                if container[idx] is None:
                    container[idx] = [] if next_is_list else {}
                container = container[idx]
            else:
                if part not in container or not isinstance(container[part], (dict, list)):
                    container[part] = [] if next_is_list else {}
                container = container[part]

        # Set the leaf value
        last = parts[-1]
        if isinstance(container, list):
            idx = int(last)
            while len(container) <= idx:
                container.append(None)
            container[idx] = value
        else:
            container[last] = value

    for compound_key, val in flat.items():
        # Handle bracket notation produced by array_format="bracket"
        # e.g. "users[0].name" → ["users", "0", "name"]
        import re
        parts = re.split(
            r"\[(\d+)\]" + re.escape(separator) + r"?|" + re.escape(separator),
            compound_key,
        )
        parts = [p for p in parts if p is not None and p != ""]
        _set_nested(root, parts, val)

    return root

---

Tests & Examples

import json

# ── helpers ──────────────────────────────────────────────────────────────────
def _pp(label: str, obj: Any) -> None:
    print(f"\n{'─' * 55}")
    print(f"  {label}")
    print('─' * 55)
    print(json.dumps(obj, indent=2, default=str))


# ── sample data ──────────────────────────────────────────────────────────────
sample = {
    "company": "Acme",
    "address": {
        "street": "123 Main St",
        "city": "Springfield",
        "geo": {"lat": 37.77, "lng": -122.41},
    },
    "employees": [
        {
            "id": 1,
            "name": "Alice",
            "skills": ["Python", "SQL"],
            "contact": {"email": "alice@acme.com", "phone": None},
        },
        {
            "id": 2,
            "name": "Bob",
            "skills": [],
            "contact": {"email": "bob@acme.com", "phone": "555-1234"},
        },
    ],
    "meta": {},          # empty dict
    "tags": [],          # empty list
    "active": True,
}

# ── flatten (default dot-index style) ────────────────────────────────────────
flat_index = flatten_json(sample)
_pp("Flattened  (array_format='index')", flat_index)

# ── flatten (bracket style) ───────────────────────────────────────────────────
flat_bracket = flatten_json(sample, array_format="bracket")
_pp("Flattened  (array_format='bracket')", flat_bracket)

# ── round-trip ────────────────────────────────────────────────────────────────
restored_index   = unflatten_json(flat_index)
restored_bracket = unflatten_json(flat_bracket)

_pp("Restored from index notation",   restored_index)
_pp("Restored from bracket notation", restored_bracket)

# ── assertions ────────────────────────────────────────────────────────────────
assert restored_index["company"]                          == "Acme"
assert restored_index["address"]["geo"]["lat"]            == 37.77
assert restored_index["employees"][0]["skills"][1]        == "SQL"
assert restored_index["employees"][1]["contact"]["phone"] == "555-1234"
assert restored_index["employees"][0]["contact"]["phone"] is None
assert restored_index["meta"]                             == {}
assert restored_index["tags"]                             == []
assert restored_bracket["employees"][1]["skills"]         == []

print("\n✅  All assertions passed!")

# ── custom separator ──────────────────────────────────────────────────────────
flat_slash = flatten_json({"a": {"b": {"c": 42}}}, separator="/")
_pp("Custom separator '/'", flat_slash)
assert flat_slash == {"a/b/c": 42}

# ── scalar root ───────────────────────────────────────────────────────────────
assert flatten_json(42) == {"": 42}

print("✅  Edge-case assertions passed!")

---

Sample Output

───────────────────────────────────────────────────────
  Flattened  (array_format='index')
───────────────────────────────────────────────────────
{
  "company": "Acme",
  "address.street": "123 Main St",
  "address.city": "Springfield",
  "address.geo.lat": 37.77,
  "address.geo.lng": -122.41,
  "employees.0.id": 1,
  "employees.0.name": "Alice",
  "employees.0.skills.0": "Python",
  "employees.0.skills.1": "SQL",
  "employees.0.contact.email": "alice@acme.com",
  "employees.0.contact.phone": null,
  "employees.1.id": 2,
  "employees.1.name": "Bob",
  "employees.1.skills": [],
  "employees.1.contact.email": "bob@acme.com",
  "employees.1.contact.phone": "555-1234",
  "meta": {},
  "tags": []
}

───────────────────────────────────────────────────────
  Flattened  (array_format='bracket')
───────────────────────────────────────────────────────
{
  "company": "Acme",
  "address.street": "123 Main St",
  ...
  "employees[0].id": 1,
  "employees[0].name": "Alice",
  "employees[0].skills[0]": "Python",
  ...
}

✅  All assertions passed!
✅  Edge-case assertions passed!

---

Key Design Decisions

Concern	Choice
Empty containers	Preserved as {} / [] leaves (not silently dropped)
None values	Preserved as null leaves
Array format	Selectable: "index" (arr.0) or "bracket" (arr[0])
Custom separator	Any non-empty string works ("/", "__", …)
Scalar root	Stored under key "" (empty string)
Inverse function	unflatten_json reconstructs the original from either format