Getting appwrite.exception.AppwriteException: Invalid document structure: for even for valid request

        requestBody = {
            "districtName": row['districtName'],
            "pincode": row['pincode'],
        }
        print(f"requestBody--> {requestBody}")
        result = databases.create_document(
            databaseId,
            collectionId,
            ID.unique(),
            requestBody
        )

from appwrite.client import Client
from appwrite.services.databases import Databases
from appwrite.id import ID
import json
import concurrent.futures



endpoint = '<ENDPOINT>'


# Replace <PROJECT_ID> with your Appwrite project ID
project_id = '<PROJECT_ID>'

# Replace <API_KEY> with your Appwrite API key
api_key = '<API_KEY>'

# Set the <DATABASE_ID> for the Appwrite database
database_id = '<DATABASE_ID>'

# Set the <COLLECTION_ID> for the Appwrite documents
collection_id = '<COLLECTION_ID>'
# Initialize the Appwrite client

client = Client().set_endpoint(endpoint).set_project(project_id).set_key(api_key)
databases = Databases(client)

# Create an Appwrite client and database object
client = Client()
client.set_endpoint(endpoint)
client.set_project(project_id)
client.set_key(api_key)
database = Databases(client)

# Define a function to create a single document in Appwrite
def create_document(document):
    result = database.create_document(database_id, collection_id, ID.unique(), document)
    return result['$id']

# Load the JSON data from the input file
with open('pincode_unique.json', 'r') as input_file:
    json_data = json.load(input_file)

    # Create a thread pool to create the documents concurrently
    with concurrent.futures.ThreadPoolExecutor(max_workers=100) as executor:
        # Submit each dictionary in the JSON data to the thread pool
        futures = [executor.submit(create_document, document) for document in json_data]

        # Print the results of each completed future
        for future in concurrent.futures.as_completed(futures):
            print(future.result())

Future<List<T>> executeConcurrently<T>(List<Future<T>> futures) async {
  final results = <T>[];

  for (final future in futures) {
    try {
      final result = await future;
      results.add(result);
    } catch (e) {
      print('Error executing future: $e');
    }
  }

  return results;
}