JSON to Python Converter

{
  "id": "ord_9F2KX",
  "status": "processing",
  "paid": true,
  "customer": { "name": "Ada Lovelace", "email": "ada@example.com", "phone": null },
  "items": [
    { "sku": "KB-75", "qty": 1, "price": 149.99 },
    { "sku": "MS-12", "qty": 2, "price": 39.5 }
  ],
  "total": 228.99
}

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


T = TypeVar("T")


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


def from_none(x: Any) -> Any:
    assert x is None
    return x


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


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


def to_float(x: Any) -> float:
    assert isinstance(x, (int, float))
    return x


def from_bool(x: Any) -> bool:
    assert isinstance(x, bool)
    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 Customer:
    name: str
    email: str
    phone: None

    def __init__(self, name: str, email: str, phone: None) -> None:
        self.name = name
        self.email = email
        self.phone = phone

    @staticmethod
    def from_dict(obj: Any) -> 'Customer':
        assert isinstance(obj, dict)
        name = from_str(obj.get("name"))
        email = from_str(obj.get("email"))
        phone = from_none(obj.get("phone"))
        return Customer(name, email, phone)

    def to_dict(self) -> dict:
        result: dict = {}
        result["name"] = from_str(self.name)
        result["email"] = from_str(self.email)
        result["phone"] = from_none(self.phone)
        return result


class Item:
    sku: str
    qty: int
    price: float

    def __init__(self, sku: str, qty: int, price: float) -> None:
        self.sku = sku
        self.qty = qty
        self.price = price

    @staticmethod
    def from_dict(obj: Any) -> 'Item':
        assert isinstance(obj, dict)
        sku = from_str(obj.get("sku"))
        qty = from_int(obj.get("qty"))
        price = from_float(obj.get("price"))
        return Item(sku, qty, price)

    def to_dict(self) -> dict:
        result: dict = {}
        result["sku"] = from_str(self.sku)
        result["qty"] = from_int(self.qty)
        result["price"] = to_float(self.price)
        return result


class Root:
    id: str
    status: str
    paid: bool
    customer: Customer
    items: List[Item]
    total: float

    def __init__(self, id: str, status: str, paid: bool, customer: Customer, items: List[Item], total: float) -> None:
        self.id = id
        self.status = status
        self.paid = paid
        self.customer = customer
        self.items = items
        self.total = total

    @staticmethod
    def from_dict(obj: Any) -> 'Root':
        assert isinstance(obj, dict)
        id = from_str(obj.get("id"))
        status = from_str(obj.get("status"))
        paid = from_bool(obj.get("paid"))
        customer = Customer.from_dict(obj.get("customer"))
        items = from_list(Item.from_dict, obj.get("items"))
        total = from_float(obj.get("total"))
        return Root(id, status, paid, customer, items, total)

    def to_dict(self) -> dict:
        result: dict = {}
        result["id"] = from_str(self.id)
        result["status"] = from_str(self.status)
        result["paid"] = from_bool(self.paid)
        result["customer"] = to_class(Customer, self.customer)
        result["items"] = from_list(lambda x: to_class(Item, x), self.items)
        result["total"] = to_float(self.total)
        return result


def root_from_dict(s: Any) -> Root:
    return Root.from_dict(s)


def root_to_dict(x: Root) -> Any:
    return to_class(Root, x)