Json til Python

from typing import Any, List, TypeVar, Callable, Type, cast


T = TypeVar("T")


def from_int(x: Any) -> int:
    assert isinstance(x, int) and not isinstance(x, bool)
    return x


def from_str(x: Any) -> str:
    assert isinstance(x, str)
    return x


def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
    assert isinstance(x, list)
    return [f(y) for y in x]


def to_class(c: Type[T], x: Any) -> dict:
    assert isinstance(x, c)
    return cast(Any, x).to_dict()


class Nested:
    a: int
    b: int

    def __init__(self, a: int, b: int) -> None:
        self.a = a
        self.b = b

    @staticmethod
    def from_dict(obj: Any) -> 'Nested':
        assert isinstance(obj, dict)
        a = from_int(obj.get("a"))
        b = int(from_str(obj.get("b")))
        return Nested(a, b)

    def to_dict(self) -> dict:
        result: dict = {}
        result["a"] = from_int(self.a)
        result["b"] = from_str(str(self.b))
        return result


class GeneratedClass:
    a: str
    arr: List[int]
    nested: Nested

    def __init__(self, a: str, arr: List[int], nested: Nested) -> None:
        self.a = a
        self.arr = arr
        self.nested = nested

    @staticmethod
    def from_dict(obj: Any) -> 'GeneratedClass':
        assert isinstance(obj, dict)
        a = from_str(obj.get("a"))
        arr = from_list(from_int, obj.get("arr"))
        nested = Nested.from_dict(obj.get("nested"))
        return GeneratedClass(a, arr, nested)

    def to_dict(self) -> dict:
        result: dict = {}
        result["a"] = from_str(self.a)
        result["arr"] = from_list(from_int, self.arr)
        result["nested"] = to_class(Nested, self.nested)
        return result


def generated_class_from_dict(s: Any) -> GeneratedClass:
    return GeneratedClass.from_dict(s)


def generated_class_to_dict(x: GeneratedClass) -> Any:
    return to_class(GeneratedClass, x)