twitter-openapi-python-generated 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

twitter_openapi_python_generated/models/community_page_actions.py

@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+    Twitter OpenAPI
+
+    Twitter OpenAPI(Swagger) specification
+
+    The version of the OpenAPI document: 0.0.1
+    Contact: yuki@yuki0311.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.community_page_delete_action_result import CommunityPageDeleteActionResult
+from twitter_openapi_python_generated.models.community_page_join_action_result import CommunityPageJoinActionResult
+from twitter_openapi_python_generated.models.community_page_leave_action_result import CommunityPageLeaveActionResult
+from twitter_openapi_python_generated.models.community_page_pin_action_result import CommunityPagePinActionResult
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CommunityPageActions(BaseModel):
+    """
+    CommunityPageActions
+    """ # noqa: E501
+    delete_action_result: CommunityPageDeleteActionResult
+    id: StrictStr
+    join_action_result: CommunityPageJoinActionResult
+    leave_action_result: CommunityPageLeaveActionResult
+    pin_action_result: CommunityPagePinActionResult
+    __properties: ClassVar[List[str]] = ["delete_action_result", "id", "join_action_result", "leave_action_result", "pin_action_result"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CommunityPageActions from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of delete_action_result
+        if self.delete_action_result:
+            _dict['delete_action_result'] = self.delete_action_result.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of join_action_result
+        if self.join_action_result:
+            _dict['join_action_result'] = self.join_action_result.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of leave_action_result
+        if self.leave_action_result:
+            _dict['leave_action_result'] = self.leave_action_result.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of pin_action_result
+        if self.pin_action_result:
+            _dict['pin_action_result'] = self.pin_action_result.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommunityPageActions from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "delete_action_result": CommunityPageDeleteActionResult.from_dict(obj["delete_action_result"]) if obj.get("delete_action_result") is not None else None,
+            "id": obj.get("id"),
+            "join_action_result": CommunityPageJoinActionResult.from_dict(obj["join_action_result"]) if obj.get("join_action_result") is not None else None,
+            "leave_action_result": CommunityPageLeaveActionResult.from_dict(obj["leave_action_result"]) if obj.get("leave_action_result") is not None else None,
+            "pin_action_result": CommunityPagePinActionResult.from_dict(obj["pin_action_result"]) if obj.get("pin_action_result") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/community_page_community.py

@@ -0,0 +1,187 @@
+# coding: utf-8
+
+"""
+    Twitter OpenAPI
+
+    Twitter OpenAPI(Swagger) specification
+
+    The version of the OpenAPI document: 0.0.1
+    Contact: yuki@yuki0311.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing_extensions import Annotated
+from twitter_openapi_python_generated.models.community_banner_media import CommunityBannerMedia
+from twitter_openapi_python_generated.models.community_id_user_results import CommunityIdUserResults
+from twitter_openapi_python_generated.models.community_join_requests_result import CommunityJoinRequestsResult
+from twitter_openapi_python_generated.models.community_page_actions import CommunityPageActions
+from twitter_openapi_python_generated.models.community_page_invites_result import CommunityPageInvitesResult
+from twitter_openapi_python_generated.models.community_relay_rule import CommunityRelayRule
+from twitter_openapi_python_generated.models.community_viewer_relationship import CommunityViewerRelationship
+from twitter_openapi_python_generated.models.type_name import TypeName
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CommunityPageCommunity(BaseModel):
+    """
+    CommunityPageCommunity
+    """ # noqa: E501
+    typename: TypeName = Field(alias="__typename")
+    actions: CommunityPageActions
+    admin_results: CommunityIdUserResults
+    created_at: StrictInt
+    creator_results: CommunityIdUserResults
+    custom_banner_media: CommunityBannerMedia
+    default_banner_media: CommunityBannerMedia
+    description: StrictStr
+    id: StrictStr
+    id_str: Annotated[str, Field(strict=True)]
+    invites_policy: StrictStr
+    invites_result: CommunityPageInvitesResult
+    is_nsfw: StrictBool
+    is_pinned: StrictBool
+    join_policy: StrictStr
+    join_requests_result: CommunityJoinRequestsResult
+    member_count: StrictInt
+    members_facepile_results: List[CommunityIdUserResults]
+    moderator_count: StrictInt
+    name: StrictStr
+    role: StrictStr
+    rules: List[CommunityRelayRule]
+    search_tags: List[StrictStr]
+    viewer_relationship: CommunityViewerRelationship
+    __properties: ClassVar[List[str]] = ["__typename", "actions", "admin_results", "created_at", "creator_results", "custom_banner_media", "default_banner_media", "description", "id", "id_str", "invites_policy", "invites_result", "is_nsfw", "is_pinned", "join_policy", "join_requests_result", "member_count", "members_facepile_results", "moderator_count", "name", "role", "rules", "search_tags", "viewer_relationship"]
+
+    @field_validator('id_str', mode="before")
+    def id_str_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if isinstance(value, str) and not re.match(r"^[0-9]+$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+$/")
+        return value
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CommunityPageCommunity from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of actions
+        if self.actions:
+            _dict['actions'] = self.actions.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of admin_results
+        if self.admin_results:
+            _dict['admin_results'] = self.admin_results.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of creator_results
+        if self.creator_results:
+            _dict['creator_results'] = self.creator_results.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of custom_banner_media
+        if self.custom_banner_media:
+            _dict['custom_banner_media'] = self.custom_banner_media.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of default_banner_media
+        if self.default_banner_media:
+            _dict['default_banner_media'] = self.default_banner_media.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of invites_result
+        if self.invites_result:
+            _dict['invites_result'] = self.invites_result.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of join_requests_result
+        if self.join_requests_result:
+            _dict['join_requests_result'] = self.join_requests_result.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in members_facepile_results (list)
+        _items = []
+        if self.members_facepile_results:
+            for _item_members_facepile_results in self.members_facepile_results:
+                _items.append(_item_members_facepile_results.to_dict() if _item_members_facepile_results is not None else None)
+            _dict['members_facepile_results'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in rules (list)
+        _items = []
+        if self.rules:
+            for _item_rules in self.rules:
+                _items.append(_item_rules.to_dict() if _item_rules is not None else None)
+            _dict['rules'] = _items
+        # override the default output from pydantic by calling `to_dict()` of viewer_relationship
+        if self.viewer_relationship:
+            _dict['viewer_relationship'] = self.viewer_relationship.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommunityPageCommunity from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "__typename": obj.get("__typename"),
+            "actions": CommunityPageActions.from_dict(obj["actions"]) if obj.get("actions") is not None else None,
+            "admin_results": CommunityIdUserResults.from_dict(obj["admin_results"]) if obj.get("admin_results") is not None else None,
+            "created_at": obj.get("created_at"),
+            "creator_results": CommunityIdUserResults.from_dict(obj["creator_results"]) if obj.get("creator_results") is not None else None,
+            "custom_banner_media": CommunityBannerMedia.from_dict(obj["custom_banner_media"]) if obj.get("custom_banner_media") is not None else None,
+            "default_banner_media": CommunityBannerMedia.from_dict(obj["default_banner_media"]) if obj.get("default_banner_media") is not None else None,
+            "description": obj.get("description"),
+            "id": obj.get("id"),
+            "id_str": obj.get("id_str"),
+            "invites_policy": obj.get("invites_policy"),
+            "invites_result": CommunityPageInvitesResult.from_dict(obj["invites_result"]) if obj.get("invites_result") is not None else None,
+            "is_nsfw": obj.get("is_nsfw"),
+            "is_pinned": obj.get("is_pinned"),
+            "join_policy": obj.get("join_policy"),
+            "join_requests_result": CommunityJoinRequestsResult.from_dict(obj["join_requests_result"]) if obj.get("join_requests_result") is not None else None,
+            "member_count": obj.get("member_count"),
+            "members_facepile_results": [CommunityIdUserResults.from_dict(_item) for _item in obj["members_facepile_results"]] if obj.get("members_facepile_results") is not None else None,
+            "moderator_count": obj.get("moderator_count"),
+            "name": obj.get("name"),
+            "role": obj.get("role"),
+            "rules": [CommunityRelayRule.from_dict(_item) for _item in obj["rules"]] if obj.get("rules") is not None else None,
+            "search_tags": obj.get("search_tags"),
+            "viewer_relationship": CommunityViewerRelationship.from_dict(obj["viewer_relationship"]) if obj.get("viewer_relationship") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/community_page_delete_action_result.py

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+    Twitter OpenAPI
+
+    Twitter OpenAPI(Swagger) specification
+
+    The version of the OpenAPI document: 0.0.1
+    Contact: yuki@yuki0311.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.type_name import TypeName
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CommunityPageDeleteActionResult(BaseModel):
+    """
+    CommunityPageDeleteActionResult
+    """ # noqa: E501
+    is_community_delete_action_result: StrictStr = Field(alias="__isCommunityDeleteActionResult")
+    typename: TypeName = Field(alias="__typename")
+    reason: StrictStr
+    __properties: ClassVar[List[str]] = ["__isCommunityDeleteActionResult", "__typename", "reason"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CommunityPageDeleteActionResult from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommunityPageDeleteActionResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "__isCommunityDeleteActionResult": obj.get("__isCommunityDeleteActionResult"),
+            "__typename": obj.get("__typename"),
+            "reason": obj.get("reason")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/community_page_invites_result.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+    Twitter OpenAPI
+
+    Twitter OpenAPI(Swagger) specification
+
+    The version of the OpenAPI document: 0.0.1
+    Contact: yuki@yuki0311.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.type_name import TypeName
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CommunityPageInvitesResult(BaseModel):
+    """
+    CommunityPageInvitesResult
+    """ # noqa: E501
+    is_community_invites_result: StrictStr = Field(alias="__isCommunityInvitesResult")
+    typename: TypeName = Field(alias="__typename")
+    message: StrictStr
+    reason: StrictStr
+    __properties: ClassVar[List[str]] = ["__isCommunityInvitesResult", "__typename", "message", "reason"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CommunityPageInvitesResult from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommunityPageInvitesResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "__isCommunityInvitesResult": obj.get("__isCommunityInvitesResult"),
+            "__typename": obj.get("__typename"),
+            "message": obj.get("message"),
+            "reason": obj.get("reason")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/community_page_join_action_result.py

@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+    Twitter OpenAPI
+
+    Twitter OpenAPI(Swagger) specification
+
+    The version of the OpenAPI document: 0.0.1
+    Contact: yuki@yuki0311.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.type_name import TypeName
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CommunityPageJoinActionResult(BaseModel):
+    """
+    CommunityPageJoinActionResult
+    """ # noqa: E501
+    is_community_join_action_result: StrictStr = Field(alias="__isCommunityJoinActionResult")
+    typename: TypeName = Field(alias="__typename")
+    __properties: ClassVar[List[str]] = ["__isCommunityJoinActionResult", "__typename"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CommunityPageJoinActionResult from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommunityPageJoinActionResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "__isCommunityJoinActionResult": obj.get("__isCommunityJoinActionResult"),
+            "__typename": obj.get("__typename")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/community_page_leave_action_result.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+    Twitter OpenAPI
+
+    Twitter OpenAPI(Swagger) specification
+
+    The version of the OpenAPI document: 0.0.1
+    Contact: yuki@yuki0311.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.type_name import TypeName
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CommunityPageLeaveActionResult(BaseModel):
+    """
+    CommunityPageLeaveActionResult
+    """ # noqa: E501
+    is_community_leave_action_result: StrictStr = Field(alias="__isCommunityLeaveActionResult")
+    typename: TypeName = Field(alias="__typename")
+    message: StrictStr
+    reason: StrictStr
+    __properties: ClassVar[List[str]] = ["__isCommunityLeaveActionResult", "__typename", "message", "reason"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CommunityPageLeaveActionResult from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommunityPageLeaveActionResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "__isCommunityLeaveActionResult": obj.get("__isCommunityLeaveActionResult"),
+            "__typename": obj.get("__typename"),
+            "message": obj.get("message"),
+            "reason": obj.get("reason")
+        })
+        return _obj
+
+