Gemini vs Kimi for Coding

Here is the Python function to achieve this. It uses recursion to traverse the nested dictionary and lists, building the dot-notation keys along the way.

def flatten_json(nested_data, parent_key='', sep='.'):
    """
    Flattens a nested JSON object (dictionary/list) into a single-level dictionary.
    
    Args:
        nested_data (dict | list): The parsed JSON data to flatten.
        parent_key (str): The base key upon which to build the dot-notation path.
        sep (str): The separator to use between key levels (default is '.').
        
    Returns:
        dict: A flat dictionary with dot-notation keys.
    """
    flattened = {}
    
    def _flatten(obj, current_key):
        # Handle dictionaries
        if isinstance(obj, dict):
            for k, v in obj.items():
                # Append the key, separated by a dot if it's not the root
                new_key = f"{current_key}{sep}{k}" if current_key else str(k)
                _flatten(v, new_key)
                
        # Handle arrays (lists)
        elif isinstance(obj, list):
            for i, v in enumerate(obj):
                # Append the array index as part of the key path
                new_key = f"{current_key}{sep}{i}" if current_key else str(i)
                _flatten(v, new_key)
                
        # Handle base cases (strings, ints, booleans, None)
        else:
            flattened[current_key] = obj
            
    _flatten(nested_data, parent_key)
    return flattened

Example Usage:

# Sample nested JSON object
json_data = {
    "user": {
        "id": 123,
        "name": {
            "first": "Alice",
            "last": "Smith"
        }
    },
    "tags": ["python", "data", "json"],
    "active": True,
    "settings": [
        {"theme": "dark"},
        {"notifications": False}
    ]
}

flat_data = flatten_json(json_data)

# Print the result nicely formatted 
import json
print(json.dumps(flat_data, indent=4))

Output:

{
    "user.id": 123,
    "user.name.first": "Alice",
    "user.name.last": "Smith",
    "tags.0": "python",
    "tags.1": "data",
    "tags.2": "json",
    "active": true,
    "settings.0.theme": "dark",
    "settings.1.notifications": false
}

How it works:

1. Helper Function (_flatten): Keeps the state contained so you don't continually create and update a bunch of intermediate dictionaries in memory. It directly writes to the parent flattened dictionary.
2. isinstance(obj, dict): Loops through key-value pairs, appending the new key to the parent path string.
3. isinstance(obj, list): Iterates via enumerate() to extract the index i alongside the value v, adding the index into the dot-notation path natively.
4. Base Case (else): Once it reaches an ending value (like a string, integer, or boolean), it adds the accumulated key path and value to the flattened dictionary.

Here's a Python function that flattens nested JSON objects (dictionaries and lists) into a single-level dictionary using dot notation:

from typing import Any, Dict, Union

def flatten_json(nested_obj: Any, separator: str = '.') -> Dict[str, Any]:
    """
    Flatten a nested JSON structure into a single-level dictionary with dot-notation keys.
    
    Args:
        nested_obj: The nested dictionary, list, or value to flatten
        separator: String used to join keys (default: '.')
        
    Returns:
        Flattened dictionary where keys represent the path to each value
        
    Example:
        >>> data = {
        ...     "user": {
        ...         "name": "John",
        ...         "roles": ["admin", "editor"],
        ...         "address": {"city": "NYC", "zip": 10001}
        ...     }
        ... }
        >>> flatten_json(data)
        {
            'user.name': 'John',
            'user.roles.0': 'admin',
            'user.roles.1': 'editor',
            'user.address.city': 'NYC',
            'user.address.zip': 10001
        }
    """
    def _flatten(obj: Any, prefix: str = '') -> Dict[str, Any]:
        items: Dict[str, Any] = {}
        
        if isinstance(obj, dict):
            for key, value in obj.items():
                # Handle keys that contain the separator by escaping or skipping
                safe_key = str(key).replace(separator, f"\\{separator}")
                new_key = f"{prefix}{separator}{safe_key}" if prefix else safe_key
                items.update(_flatten(value, new_key))
                
        elif isinstance(obj, list):
            for index, value in enumerate(obj):
                new_key = f"{prefix}{separator}{index}" if prefix else str(index)
                items.update(_flatten(value, new_key))
                
        else:
            # Base case: primitive value (str, int, bool, None, etc.)
            items[prefix] = obj
            
        return items
    
    # Handle edge case where input is not a container
    if not isinstance(nested_obj, (dict, list)):
        return {separator: nested_obj} if separator != '' else {'': nested_obj}
        
    return _flatten(nested_obj)


# Usage examples
if __name__ == "__main__":
    # Complex nested example
    data = {
        "company": "TechCorp",
        "employees": [
            {
                "name": "Alice",
                "skills": ["Python", "Go"],
                "contact": {"email": "alice@example.com", "phone": None}
            },
            {
                "name": "Bob",
                "skills": ["JavaScript"],
                "contact": {"email": "bob@example.com"}
            }
        ],
        "metadata": {
            "active": True,
            "count": 2
        }
    }
    
    flat = flatten_json(data)
    for key, value in flat.items():
        print(f"{key}: {value}")

Key Features:

1. Recursive traversal - Handles arbitrary nesting depth of dicts and lists
2. Array indexing - List indices become part of the key path (e.g., employees.0.name)
3. Type preservation - Primitive values (strings, numbers, booleans, None) are kept as-is
4. Separator escaping - Keys containing the dot character are escaped to avoid ambiguity
5. Edge case handling - Gracefully handles empty containers and non-container inputs

Output for the example above:

company: TechCorp
employees.0.name: Alice
employees.0.skills.0: Python
employees.0.skills.1: Go
employees.0.contact.email: alice@example.com
employees.0.contact.phone: None
employees.1.name: Bob
employees.1.skills.0: JavaScript
employees.1.contact.email: bob@example.com
metadata.active: True
metadata.count: 2

Note: If you need to unflatten this back to nested structure later, be aware that keys containing the separator (e.g., a key literally named "first.name") will be indistinguishable from nested paths unless you implement the escaping/unescaping logic on both ends.