from itertools import chain
import re
from timeit import default_timer as timer
start = timer()

number_regex_1="-?(?:0|\d+)(?:\.\d+)?" #это часть регулярки говорит что число может быть нулем целым или дробным
number_regex_2="(?:[eE][+-]?\d+)" #Это часть отвечает за эекспоненциальную форму числа
regex_for_all="\s(.*)" #\r\n\t\f\v - это делает \s* а .* означает любой символ
number_regex = re.compile(r"(-?(?:0|\d+)(?:\.\d+)?(?:[eE][+-]?\d+)?)\s*(.*)", re.DOTALL)
string_regex_1='[^\\"]' #не встречаются символы закрывающую строку
string_regex_2='\\["\\/bfnrt]' #/ один из следющих символов
string_regex_3="\\u[0-9a-fA-F]{4}" #это нкжно для 4hex \u
string_regex_4="*?" #так называемое lazy выражение озночает как можно меньшне повторений
string_regex = re.compile(r'("(?:[^\\"]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*?")\s*(.*)', re.DOTALL)


def parse_number(src):
    match = number_regex.match(src)
    if match is not None:
        number, src = match.groups()
        yield eval(number), src

def parse_string(src):
    match = string_regex.match(src)
    if match is not None:
        string, src = match.groups()
        yield eval(string), src

def parse_word(word, value=None):
    l = len(word)
    def result(src):
        if src.startswith(word)==True:
            yield value, src[l:].lstrip()

    return result

parse_true = parse_word("true", True)
parse_false = parse_word("false", False)
parse_null = parse_word("null", None)

def parse_value(src):
    for match in chain(
        parse_string(src),
        parse_number(src),

        parse_object(src),
        parse_true(src),
        parse_false(src),
        parse_null(src),
    ):
        yield match
        return

parse_comma = parse_word(",")
parse_left_curly_bracket = parse_word("{")
parse_right_curly_bracket = parse_word("}")

def parse_object(src):

    for _, tsrc in parse_left_curly_bracket(src):
        for _, tsrc in parse_right_curly_bracket(tsrc):
            yield {}, tsrc
            return

    for _, src in parse_left_curly_bracket(src):
        for items, src in parse_comma_separated_keyvalues(src):
            for _, src in parse_right_curly_bracket(src):
                yield items, src


parse_colon = parse_word(":")

def parse_keyvalue(src):
    for key,src in parse_string(src):
        for _,src in parse_colon(src):
            for value,src in parse_value(src):
                yield {key: value}, src


def parse_comma_separated_keyvalues(src):
    for keyvalue,ssrc in parse_keyvalue(src):
        for _,ssrc in parse_comma(ssrc):
            for keyvalues,ssrc in parse_comma_separated_keyvalues(ssrc):

                keyvalue.update(keyvalues)
                yield keyvalue, ssrc
                return

    for keyvalue, src in parse_keyvalue(src):
        yield keyvalue, src

def parse(s):
    s = s.strip()
    match = list(parse_value(s))

    result, src = match[0]

    return result



end = timer()
print("--- %s seconds ---" % (end - start))