Class

class Class:
    @staticmethod
    def from_json(json: Any) -> Class:
        result = Class(
            json["id"],
            json["qname"],
            json.get("decorators", []),
            json.get("superclasses", []),
            json.get("is_public", True),
            json.get("reexported_by", []),
            ClassDocumentation(
                description=json.get("description", ""),
                full_docstring=json.get("docstring", ""),
            ),
            json.get("code", ""),
            [
                Attribute.from_json(instance_attribute, json["id"])
                for instance_attribute in json.get("instance_attributes", [])
            ],
        )

        for method_id in json["methods"]:
            result.add_method(method_id)

        return result

    def __init__(
        self,
        id_: str,
        qname: str,
        decorators: list[str],
        superclasses: list[str],
        is_public: bool,
        reexported_by: list[str],
        documentation: ClassDocumentation,
        code: str,
        instance_attributes: list[Attribute],
    ) -> None:
        self.id: str = id_
        self.qname: str = qname
        self.decorators: list[str] = decorators
        self.superclasses: list[str] = superclasses
        self.methods: list[str] = []
        self.is_public: bool = is_public
        self.reexported_by: list[str] = reexported_by
        self.documentation: ClassDocumentation = documentation
        self.code: str = code
        self.instance_attributes = instance_attributes
        self.formatted_code: Optional[str] = None

    @property
    def name(self) -> str:
        return self.qname.split(".")[-1]

    def add_method(self, method_id: str) -> None:
        self.methods.append(method_id)

    def to_json(self) -> Any:
        return {
            "id": self.id,
            "name": self.name,
            "qname": self.qname,
            "decorators": self.decorators,
            "superclasses": self.superclasses,
            "methods": self.methods,
            "is_public": self.is_public,
            "reexported_by": self.reexported_by,
            "description": self.documentation.description,
            "docstring": self.documentation.full_docstring,
            "code": self.code,
            "instance_attributes": [
                attribute.to_json() for attribute in self.instance_attributes
            ],
        }

    def get_formatted_code(self) -> str:
        if self.formatted_code is None:
            self.formatted_code = _generate_formatted_code(self)
        return self.formatted_code

    def __repr__(self) -> str:
        return "Class(id=" + self.id + ")"