twitter-openapi-python-generated 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

twitter_openapi_python_generated/models/tweet_interstitial_text_entity_ref.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, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TweetInterstitialTextEntityRef(BaseModel):
+    """
+    TweetInterstitialTextEntityRef
+    """ # noqa: E501
+    type: StrictStr
+    url: StrictStr
+    url_type: StrictStr = Field(alias="urlType")
+    __properties: ClassVar[List[str]] = ["type", "url", "urlType"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['TimelineUrl']):
+            raise ValueError("must be one of enum values ('TimelineUrl')")
+        return value
+
+    @field_validator('url_type')
+    def url_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['ExternalUrl']):
+            raise ValueError("must be one of enum values ('ExternalUrl')")
+        return value
+
+    model_config = {
+        "populate_by_name": 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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TweetInterstitialTextEntityRef 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 TweetInterstitialTextEntityRef from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "url": obj.get("url"),
+            "urlType": obj.get("urlType")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/tweet_legacy.py

@@ -18,18 +18,16 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, Field, StrictBool, StrictInt, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
-from pydantic import BaseModel, StrictBool, StrictInt, StrictStr, field_validator
-from pydantic import Field
 from typing_extensions import Annotated
 from twitter_openapi_python_generated.models.entities import Entities
 from twitter_openapi_python_generated.models.extended_entities import ExtendedEntities
+from twitter_openapi_python_generated.models.quoted_status_permalink import QuotedStatusPermalink
 from twitter_openapi_python_generated.models.self_thread import SelfThread
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from twitter_openapi_python_generated.models.tweet_legacy_scopes import TweetLegacyScopes
+from typing import Optional, Set
+from typing_extensions import Self
 
 class TweetLegacy(BaseModel):
     """
@@ -37,6 +35,7 @@ class TweetLegacy(BaseModel):
     """ # noqa: E501
     bookmark_count: StrictInt
     bookmarked: StrictBool
+    conversation_control: Optional[Dict[str, Any]] = None
     conversation_id_str: Annotated[str, Field(strict=True)]
     created_at: Annotated[str, Field(strict=True)]
     display_text_range: List[StrictInt]
@@ -46,18 +45,26 @@ class TweetLegacy(BaseModel):
     favorited: StrictBool
     full_text: StrictStr
     id_str: Annotated[str, Field(strict=True)]
+    in_reply_to_screen_name: Optional[StrictStr] = None
+    in_reply_to_status_id_str: Optional[Annotated[str, Field(strict=True)]] = None
+    in_reply_to_user_id_str: Optional[Annotated[str, Field(strict=True)]] = None
     is_quote_status: StrictBool
     lang: StrictStr
+    limited_actions: Optional[StrictStr] = None
+    place: Optional[Dict[str, Any]] = None
     possibly_sensitive: Optional[StrictBool] = False
     possibly_sensitive_editable: Optional[StrictBool] = False
     quote_count: StrictInt
+    quoted_status_id_str: Optional[Annotated[str, Field(strict=True)]] = None
+    quoted_status_permalink: Optional[QuotedStatusPermalink] = None
     reply_count: StrictInt
     retweet_count: StrictInt
     retweeted: StrictBool
     retweeted_status_result: Optional[ItemResult] = None
+    scopes: Optional[TweetLegacyScopes] = None
     self_thread: Optional[SelfThread] = None
     user_id_str: Annotated[str, Field(strict=True)]
-    __properties: ClassVar[List[str]] = ["bookmark_count", "bookmarked", "conversation_id_str", "created_at", "display_text_range", "entities", "extended_entities", "favorite_count", "favorited", "full_text", "id_str", "is_quote_status", "lang", "possibly_sensitive", "possibly_sensitive_editable", "quote_count", "reply_count", "retweet_count", "retweeted", "retweeted_status_result", "self_thread", "user_id_str"]
+    __properties: ClassVar[List[str]] = ["bookmark_count", "bookmarked", "conversation_control", "conversation_id_str", "created_at", "display_text_range", "entities", "extended_entities", "favorite_count", "favorited", "full_text", "id_str", "in_reply_to_screen_name", "in_reply_to_status_id_str", "in_reply_to_user_id_str", "is_quote_status", "lang", "limited_actions", "place", "possibly_sensitive", "possibly_sensitive_editable", "quote_count", "quoted_status_id_str", "quoted_status_permalink", "reply_count", "retweet_count", "retweeted", "retweeted_status_result", "scopes", "self_thread", "user_id_str"]
 
     @field_validator('conversation_id_str')
     def conversation_id_str_validate_regular_expression(cls, value):
@@ -80,6 +87,46 @@ class TweetLegacy(BaseModel):
             raise ValueError(r"must validate the regular expression /^[0-9]+$/")
         return value
 
+    @field_validator('in_reply_to_status_id_str')
+    def in_reply_to_status_id_str_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+$/")
+        return value
+
+    @field_validator('in_reply_to_user_id_str')
+    def in_reply_to_user_id_str_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+$/")
+        return value
+
+    @field_validator('limited_actions')
+    def limited_actions_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['limited_replies', 'community_tweet_non_member_public_community', 'non_compliant', 'dynamic_product_ad']):
+            raise ValueError("must be one of enum values ('limited_replies', 'community_tweet_non_member_public_community', 'non_compliant', 'dynamic_product_ad')")
+        return value
+
+    @field_validator('quoted_status_id_str')
+    def quoted_status_id_str_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9]+$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+$/")
+        return value
+
     @field_validator('user_id_str')
     def user_id_str_validate_regular_expression(cls, value):
         """Validates the regular expression"""
@@ -104,7 +151,7 @@ class TweetLegacy(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of TweetLegacy from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -118,10 +165,12 @@ class TweetLegacy(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of entities
@@ -130,16 +179,22 @@ class TweetLegacy(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of extended_entities
         if self.extended_entities:
             _dict['extended_entities'] = self.extended_entities.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of quoted_status_permalink
+        if self.quoted_status_permalink:
+            _dict['quoted_status_permalink'] = self.quoted_status_permalink.to_dict()
         # override the default output from pydantic by calling `to_dict()` of retweeted_status_result
         if self.retweeted_status_result:
             _dict['retweeted_status_result'] = self.retweeted_status_result.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of scopes
+        if self.scopes:
+            _dict['scopes'] = self.scopes.to_dict()
         # override the default output from pydantic by calling `to_dict()` of self_thread
         if self.self_thread:
             _dict['self_thread'] = self.self_thread.to_dict()
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of TweetLegacy from a dict"""
         if obj is None:
             return None
@@ -150,25 +205,34 @@ class TweetLegacy(BaseModel):
         _obj = cls.model_validate({
             "bookmark_count": obj.get("bookmark_count"),
             "bookmarked": obj.get("bookmarked"),
+            "conversation_control": obj.get("conversation_control"),
             "conversation_id_str": obj.get("conversation_id_str"),
             "created_at": obj.get("created_at"),
             "display_text_range": obj.get("display_text_range"),
-            "entities": Entities.from_dict(obj.get("entities")) if obj.get("entities") is not None else None,
-            "extended_entities": ExtendedEntities.from_dict(obj.get("extended_entities")) if obj.get("extended_entities") is not None else None,
+            "entities": Entities.from_dict(obj["entities"]) if obj.get("entities") is not None else None,
+            "extended_entities": ExtendedEntities.from_dict(obj["extended_entities"]) if obj.get("extended_entities") is not None else None,
             "favorite_count": obj.get("favorite_count"),
             "favorited": obj.get("favorited"),
             "full_text": obj.get("full_text"),
             "id_str": obj.get("id_str"),
+            "in_reply_to_screen_name": obj.get("in_reply_to_screen_name"),
+            "in_reply_to_status_id_str": obj.get("in_reply_to_status_id_str"),
+            "in_reply_to_user_id_str": obj.get("in_reply_to_user_id_str"),
             "is_quote_status": obj.get("is_quote_status"),
             "lang": obj.get("lang"),
+            "limited_actions": obj.get("limited_actions"),
+            "place": obj.get("place"),
             "possibly_sensitive": obj.get("possibly_sensitive") if obj.get("possibly_sensitive") is not None else False,
             "possibly_sensitive_editable": obj.get("possibly_sensitive_editable") if obj.get("possibly_sensitive_editable") is not None else False,
             "quote_count": obj.get("quote_count"),
+            "quoted_status_id_str": obj.get("quoted_status_id_str"),
+            "quoted_status_permalink": QuotedStatusPermalink.from_dict(obj["quoted_status_permalink"]) if obj.get("quoted_status_permalink") is not None else None,
             "reply_count": obj.get("reply_count"),
             "retweet_count": obj.get("retweet_count"),
             "retweeted": obj.get("retweeted"),
-            "retweeted_status_result": ItemResult.from_dict(obj.get("retweeted_status_result")) if obj.get("retweeted_status_result") is not None else None,
-            "self_thread": SelfThread.from_dict(obj.get("self_thread")) if obj.get("self_thread") is not None else None,
+            "retweeted_status_result": ItemResult.from_dict(obj["retweeted_status_result"]) if obj.get("retweeted_status_result") is not None else None,
+            "scopes": TweetLegacyScopes.from_dict(obj["scopes"]) if obj.get("scopes") is not None else None,
+            "self_thread": SelfThread.from_dict(obj["self_thread"]) if obj.get("self_thread") is not None else None,
             "user_id_str": obj.get("user_id_str")
         })
         return _obj

twitter_openapi_python_generated/models/tweet_legacy_scopes.py

@@ -0,0 +1,88 @@
+# 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, StrictBool
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TweetLegacyScopes(BaseModel):
+    """
+    TweetLegacyScopes
+    """ # noqa: E501
+    followers: StrictBool
+    __properties: ClassVar[List[str]] = ["followers"]
+
+    model_config = {
+        "populate_by_name": 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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TweetLegacyScopes 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 TweetLegacyScopes from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "followers": obj.get("followers")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/tweet_previous_counts.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, StrictInt
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TweetPreviousCounts(BaseModel):
+    """
+    TweetPreviousCounts
+    """ # noqa: E501
+    bookmark_count: StrictInt
+    favorite_count: StrictInt
+    quote_count: StrictInt
+    reply_count: StrictInt
+    retweet_count: StrictInt
+    __properties: ClassVar[List[str]] = ["bookmark_count", "favorite_count", "quote_count", "reply_count", "retweet_count"]
+
+    model_config = {
+        "populate_by_name": 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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TweetPreviousCounts 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 TweetPreviousCounts from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "bookmark_count": obj.get("bookmark_count"),
+            "favorite_count": obj.get("favorite_count"),
+            "quote_count": obj.get("quote_count"),
+            "reply_count": obj.get("reply_count"),
+            "retweet_count": obj.get("retweet_count")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/tweet_result_by_rest_id_data.py

@@ -18,15 +18,11 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, Field
 from typing import Any, ClassVar, Dict, List
-from pydantic import BaseModel
-from pydantic import Field
 from twitter_openapi_python_generated.models.item_result import ItemResult
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class TweetResultByRestIdData(BaseModel):
     """
@@ -52,7 +48,7 @@ class TweetResultByRestIdData(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of TweetResultByRestIdData from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -66,10 +62,12 @@ class TweetResultByRestIdData(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of tweet_result
@@ -78,7 +76,7 @@ class TweetResultByRestIdData(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of TweetResultByRestIdData from a dict"""
         if obj is None:
             return None
@@ -87,7 +85,7 @@ class TweetResultByRestIdData(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "tweetResult": ItemResult.from_dict(obj.get("tweetResult")) if obj.get("tweetResult") is not None else None
+            "tweetResult": ItemResult.from_dict(obj["tweetResult"]) if obj.get("tweetResult") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/tweet_result_by_rest_id_response.py

@@ -18,14 +18,11 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Any, ClassVar, Dict, List
 from pydantic import BaseModel
+from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.tweet_result_by_rest_id_data import TweetResultByRestIdData
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class TweetResultByRestIdResponse(BaseModel):
     """
@@ -51,7 +48,7 @@ class TweetResultByRestIdResponse(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of TweetResultByRestIdResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -65,10 +62,12 @@ class TweetResultByRestIdResponse(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of data
@@ -77,7 +76,7 @@ class TweetResultByRestIdResponse(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of TweetResultByRestIdResponse from a dict"""
         if obj is None:
             return None
@@ -86,7 +85,7 @@ class TweetResultByRestIdResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": TweetResultByRestIdData.from_dict(obj.get("data")) if obj.get("data") is not None else None
+            "data": TweetResultByRestIdData.from_dict(obj["data"]) if obj.get("data") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/tweet_retweeters_response.py

@@ -18,14 +18,11 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Any, ClassVar, Dict, List
 from pydantic import BaseModel
+from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.tweet_retweeters_response_data import TweetRetweetersResponseData
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class TweetRetweetersResponse(BaseModel):
     """
@@ -51,7 +48,7 @@ class TweetRetweetersResponse(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of TweetRetweetersResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -65,10 +62,12 @@ class TweetRetweetersResponse(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of data
@@ -77,7 +76,7 @@ class TweetRetweetersResponse(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of TweetRetweetersResponse from a dict"""
         if obj is None:
             return None
@@ -86,7 +85,7 @@ class TweetRetweetersResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": TweetRetweetersResponseData.from_dict(obj.get("data")) if obj.get("data") is not None else None
+            "data": TweetRetweetersResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None
         })
         return _obj