If you are using Django 1.8 you can create your own model field that can store a json. This class will make sure that you have the right JSON format as well.

import json
from django.db import models

class JsonField(models.TextField):
    """
    Stores json-able python objects as json.
    """
    def get_db_prep_value(self, value, connection, prepared=False):
        try:
            return json.dumps(value)
        except TypeError:
            BAD_DATA.error(
                "cannot serialize %s to store in a JsonField", str(value)
            )
            return ""

    def from_db_value(self, value, expression, connection, context):
        if value == "":
            return None
        try:
            return json.loads(value)
        except TypeError:
            BAD_DATA.error("cannot load dictionary field -- type error")
            return None

I suggest to use both read and write modes to fulfill this task.

First you have to read the current content of the file by using the read state and then store them in a variable.

try:
with open('data.json') as json_file:
    json_data = json.load(json_file)

Next, update the variable with the values you need.

json_data['new_key'] = []
json_data['new_key'].append("1")

Finally, you have to write to the file with the current content and the old content.

with open('data.json', 'w') as outfile:
    json.dump(json_data, outfile)

Optional Step if the JSON file is empty:

import json
try:
    with open('data.json') as json_file:
        json_data = json.load(json_file)
except json.decoder.JSONDecodeError:
    with open('data.json', 'w') as outfile:
        json_data = {}
        json.dump(json_data, outfile)

You don't use typing properly. Parametrizing generic types should be done using brackets notation (aka __getitem__) not parenthesis (aka instantiation).

You also don't use any feature of dataclasses in your defined classes, so you might as well drop that dependency. Or you could use it properly so that Country(**json_data) will build the whole thing; but:

• Keys in the JSON data are not valid python identifiers, you would need to convert them;
• You would need to handle converting children "manually" after the __init__ took place;
• You will need to swap the order in which you define classes due to scope evaluation.

The closest we would come should be something along the lines of:

from dataclasses import dataclass
from typing import List


def convert_keys(dct):
    return {name.replace('-', '_'): value for name, value in dct.items()}


@dataclass
class Street:
    city_id: int
    name: str
    street_id: int


@dataclass
class City:
    state_id: int
    name: str
    city_id: int
    streets: List[Street]

    def __post_init__(self):
        self.streets = [Street(**convert_keys(street)) for street in self.streets]


@dataclass
class State:
    country_id: int
    name: str
    state_id: int
    cities: List[City]

    def __post_init__(self):
        self.cities = [City(**convert_keys(city)) for city in self.cities]


@dataclass
class Country:
    country_id: int
    name: str
    states: List[State]

    def __port_init__(self):
        self.states = [State(**convert_keys(state)) for state in self.states]

Initiate the call using Country(**convert_keys(json_data)). But this solution doesn't necessary feel cleaner than yours.

Now as regards to using these classes as a mean to store data into a relational database, we need to examine usage.

The DB API 2.0 tells us that you can expect to be able to:

cursor.execute('INSERT INTO Street VALUES (?, ?, ?)', (city_id, name, street_id))

Which means that we need to:

1. Be able to convert these classes to tuples;
2. Remove the reverse relationship that we had so much troubles parsing properly Country.states, State.cities, and City.streets).

So here we go, trying to patch our approach. We could use dataclasses.astuple to convert or objects to proper parameters for our query, but we would still need a specific parser to recursively traverse nested JSON layers. Coupling that with the invalid identifiers issue, I don't think storing the data into intermediate classes makes much sense. Instead I would rather write them directly in the database:

def parse_country(cursor, json_data):
    country_id = json_data['country-id']
    name = json_data['name']
    cursor.execute('INSERT INTO Country VALUES (?, ?)', (country_id, name))
    for state in json_data['states']:
        parse_state(cursor, state)


def parse_state(cursor, json_data):
    state_id = json_data['state-id']
    name = json_data['name']
    country_id = json_data['country-id']
    cursor.execute('INSERT INTO State VALUES (?, ?, ?)', (state_id, name, country_id))
    for city in json_data['cities']:
        parse_city(cursor, city)


def parse_city(cursor, json_data):
    city_id = json_data['city-id']
    name = json_data['name']
    state_id = json_data['state-id']
    cursor.execute('INSERT INTO City VALUES (?, ?, ?)', (city_id, name, state_id))
    for street in json_data['streets']:
        parse_street(cursor, street)


def parse_street(cursor, json_data):
    street_id = json_data['street-id']
    name = json_data['name']
    city_id = json_data['city-id']
    cursor.execute('INSERT INTO Street VALUES (?, ?, ?)', (street_id, name, city_id))

And that's pretty much your original code except the data is now in DB and not in memory. Usage being:

conn = # create appropriate DB connection here
with conn:
    parse_country(conn.cursor(), json_data)

The answer is (as usual) that is depends. If this data is going to be used for reporting and especially ad-hoc reporting, you probably want to pull the variables out into a proper relational model. Another reason might be if you need to expose that data in multiple formats. If you don't need to do any of that then the option of keeping the documents as-is becomes more appealing.

As amon notes, you can store JSON in blobs in a relational DB. The reason you might want to use NoSQL is scalability, speed, and potentially cost. If you already have a relational DB and you don't have a large amount of documents to store (e.g. millions) it might not be worth adding an additional DB. A lot depends on the context. If you are running on a cloud provider, spinning up a NoSQL DB for this might be less effort than getting the DB setup to hold the blobs.

If the structure of each of the files is different, save yourself any effort and put them in a Document DB (e.g. MongoDB).

If the structure of the JSON data is the same for each "word" (which it looks like it is) extract the data and store it in tables: Word, Meaning, and Synonym

The tables would be keyed on word, or you could add a surrogate key:

Word: [word, wordset_id]
Meaning: [word, meaning_id, def, example, speech_part]
Synonym: [word, synonym_word]

Instead of escaping yourself, you should just use parameterized values:

cursor.execute("UPDATE TABLE1 SET FIELD1 = ? WHERE FIELD2 = 'some value'", (json.dumps(pythonDictionary)) )

How to use variables in SQL statement in Python?

use json.dumps(json_value) to convert your json object(python object) in a json string that you can insert in a text field in mysql

http://docs.python.org/library/json.html