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

twitter_openapi_python_generated/models/community_search_results.py

@@ -0,0 +1,95 @@
+# 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_search_community import CommunitySearchCommunity
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CommunitySearchResults(BaseModel):
+    """
+    CommunitySearchResults
+    """ # noqa: E501
+    id: StrictStr
+    result: CommunitySearchCommunity
+    __properties: ClassVar[List[str]] = ["id", "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 CommunitySearchResults 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 result
+        if self.result:
+            _dict['result'] = self.result.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommunitySearchResults from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "result": CommunitySearchCommunity.from_dict(obj["result"]) if obj.get("result") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/community_settings_actions.py

@@ -0,0 +1,101 @@
+# 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_join_action_result_union import CommunityJoinActionResultUnion
+from twitter_openapi_python_generated.models.community_list_members_action_result import CommunityListMembersActionResult
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CommunitySettingsActions(BaseModel):
+    """
+    CommunitySettingsActions
+    """ # noqa: E501
+    id: StrictStr
+    join_action_result: CommunityJoinActionResultUnion
+    list_members_action_result: CommunityListMembersActionResult
+    __properties: ClassVar[List[str]] = ["id", "join_action_result", "list_members_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 CommunitySettingsActions 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 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 list_members_action_result
+        if self.list_members_action_result:
+            _dict['list_members_action_result'] = self.list_members_action_result.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommunitySettingsActions from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "join_action_result": CommunityJoinActionResultUnion.from_dict(obj["join_action_result"]) if obj.get("join_action_result") is not None else None,
+            "list_members_action_result": CommunityListMembersActionResult.from_dict(obj["list_members_action_result"]) if obj.get("list_members_action_result") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/community_settings_community.py

@@ -0,0 +1,183 @@
+# 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_facepile_user_results import CommunityFacepileUserResults
+from twitter_openapi_python_generated.models.community_hashtag_slice import CommunityHashtagSlice
+from twitter_openapi_python_generated.models.community_join_requests_result import CommunityJoinRequestsResult
+from twitter_openapi_python_generated.models.community_primary_topic_name import CommunityPrimaryTopicName
+from twitter_openapi_python_generated.models.community_relay_rule import CommunityRelayRule
+from twitter_openapi_python_generated.models.community_settings_actions import CommunitySettingsActions
+from twitter_openapi_python_generated.models.community_settings_creator_results import CommunitySettingsCreatorResults
+from twitter_openapi_python_generated.models.community_settings_invites_result import CommunitySettingsInvitesResult
+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 CommunitySettingsCommunity(BaseModel):
+    """
+    CommunitySettingsCommunity
+    """ # noqa: E501
+    typename: TypeName = Field(alias="__typename")
+    actions: CommunitySettingsActions
+    created_at: StrictInt
+    creator_results: CommunitySettingsCreatorResults
+    custom_banner_media: CommunityBannerMedia
+    default_banner_media: CommunityBannerMedia
+    description: StrictStr
+    id: StrictStr
+    invites_result: CommunitySettingsInvitesResult
+    is_member: StrictBool
+    is_nsfw: StrictBool
+    join_policy: StrictStr
+    join_requests_result: CommunityJoinRequestsResult
+    member_count: StrictInt
+    members_facepile_results: List[CommunityFacepileUserResults]
+    name: StrictStr
+    primary_community_topic: CommunityPrimaryTopicName
+    rest_id: Annotated[str, Field(strict=True)]
+    role: StrictStr
+    rules: List[CommunityRelayRule]
+    trending_hashtags_slice: CommunityHashtagSlice
+    __properties: ClassVar[List[str]] = ["__typename", "actions", "created_at", "creator_results", "custom_banner_media", "default_banner_media", "description", "id", "invites_result", "is_member", "is_nsfw", "join_policy", "join_requests_result", "member_count", "members_facepile_results", "name", "primary_community_topic", "rest_id", "role", "rules", "trending_hashtags_slice"]
+
+    @field_validator('rest_id', mode="before")
+    def rest_id_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 CommunitySettingsCommunity 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 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 primary_community_topic
+        if self.primary_community_topic:
+            _dict['primary_community_topic'] = self.primary_community_topic.to_dict()
+        # 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 trending_hashtags_slice
+        if self.trending_hashtags_slice:
+            _dict['trending_hashtags_slice'] = self.trending_hashtags_slice.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommunitySettingsCommunity 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": CommunitySettingsActions.from_dict(obj["actions"]) if obj.get("actions") is not None else None,
+            "created_at": obj.get("created_at"),
+            "creator_results": CommunitySettingsCreatorResults.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"),
+            "invites_result": CommunitySettingsInvitesResult.from_dict(obj["invites_result"]) if obj.get("invites_result") is not None else None,
+            "is_member": obj.get("is_member"),
+            "is_nsfw": obj.get("is_nsfw"),
+            "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": [CommunityFacepileUserResults.from_dict(_item) for _item in obj["members_facepile_results"]] if obj.get("members_facepile_results") is not None else None,
+            "name": obj.get("name"),
+            "primary_community_topic": CommunityPrimaryTopicName.from_dict(obj["primary_community_topic"]) if obj.get("primary_community_topic") is not None else None,
+            "rest_id": obj.get("rest_id"),
+            "role": obj.get("role"),
+            "rules": [CommunityRelayRule.from_dict(_item) for _item in obj["rules"]] if obj.get("rules") is not None else None,
+            "trending_hashtags_slice": CommunityHashtagSlice.from_dict(obj["trending_hashtags_slice"]) if obj.get("trending_hashtags_slice") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/community_settings_creator.py

@@ -0,0 +1,106 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.community_settings_creator_core import CommunitySettingsCreatorCore
+from twitter_openapi_python_generated.models.community_settings_creator_verification import CommunitySettingsCreatorVerification
+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 CommunitySettingsCreator(BaseModel):
+    """
+    CommunitySettingsCreator
+    """ # noqa: E501
+    typename: TypeName = Field(alias="__typename")
+    core: CommunitySettingsCreatorCore
+    id: StrictStr
+    is_blue_verified: StrictBool
+    verification: CommunitySettingsCreatorVerification
+    __properties: ClassVar[List[str]] = ["__typename", "core", "id", "is_blue_verified", "verification"]
+
+    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 CommunitySettingsCreator 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 core
+        if self.core:
+            _dict['core'] = self.core.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of verification
+        if self.verification:
+            _dict['verification'] = self.verification.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommunitySettingsCreator 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"),
+            "core": CommunitySettingsCreatorCore.from_dict(obj["core"]) if obj.get("core") is not None else None,
+            "id": obj.get("id"),
+            "is_blue_verified": obj.get("is_blue_verified"),
+            "verification": CommunitySettingsCreatorVerification.from_dict(obj["verification"]) if obj.get("verification") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/community_settings_creator_core.py

@@ -0,0 +1,89 @@
+# 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 typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CommunitySettingsCreatorCore(BaseModel):
+    """
+    CommunitySettingsCreatorCore
+    """ # noqa: E501
+    screen_name: StrictStr
+    __properties: ClassVar[List[str]] = ["screen_name"]
+
+    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 CommunitySettingsCreatorCore 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 CommunitySettingsCreatorCore from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "screen_name": obj.get("screen_name")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/community_settings_creator_results.py

@@ -0,0 +1,95 @@
+# 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_settings_creator import CommunitySettingsCreator
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CommunitySettingsCreatorResults(BaseModel):
+    """
+    CommunitySettingsCreatorResults
+    """ # noqa: E501
+    id: StrictStr
+    result: CommunitySettingsCreator
+    __properties: ClassVar[List[str]] = ["id", "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 CommunitySettingsCreatorResults 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 result
+        if self.result:
+            _dict['result'] = self.result.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommunitySettingsCreatorResults from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "result": CommunitySettingsCreator.from_dict(obj["result"]) if obj.get("result") is not None else None
+        })
+        return _obj
+
+