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

twitter_openapi_python_generated/models/preroll.py

@@ -0,0 +1,97 @@
+# 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.preroll_media_info import PrerollMediaInfo
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class Preroll(BaseModel):
+    """
+    Preroll
+    """ # noqa: E501
+    dynamic_preroll_type: StrictStr = Field(alias="dynamicPrerollType")
+    media_info: PrerollMediaInfo = Field(alias="mediaInfo")
+    preroll_id: StrictStr = Field(alias="prerollId")
+    __properties: ClassVar[List[str]] = ["dynamicPrerollType", "mediaInfo", "prerollId"]
+
+    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 Preroll 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 media_info
+        if self.media_info:
+            _dict['mediaInfo'] = self.media_info.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Preroll from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "dynamicPrerollType": obj.get("dynamicPrerollType"),
+            "mediaInfo": PrerollMediaInfo.from_dict(obj["mediaInfo"]) if obj.get("mediaInfo") is not None else None,
+            "prerollId": obj.get("prerollId")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/preroll_call_to_action.py

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

twitter_openapi_python_generated/models/preroll_media_info.py

@@ -0,0 +1,118 @@
+# 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
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.preroll_call_to_action import PrerollCallToAction
+from twitter_openapi_python_generated.models.preroll_video_variant import PrerollVideoVariant
+from twitter_openapi_python_generated.models.user_results import UserResults
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class PrerollMediaInfo(BaseModel):
+    """
+    PrerollMediaInfo
+    """ # noqa: E501
+    advertiser_name: StrictStr = Field(alias="advertiserName")
+    advertiser_profile_image_url: StrictStr = Field(alias="advertiserProfileImageUrl")
+    call_to_action: PrerollCallToAction = Field(alias="callToAction")
+    duration_millis: StrictInt = Field(alias="durationMillis")
+    publisher_results: UserResults = Field(alias="publisherResults")
+    render_ad_by_advertiser_name: StrictBool = Field(alias="renderAdByAdvertiserName")
+    uuid: StrictStr
+    video_variants: List[PrerollVideoVariant] = Field(alias="videoVariants")
+    __properties: ClassVar[List[str]] = ["advertiserName", "advertiserProfileImageUrl", "callToAction", "durationMillis", "publisherResults", "renderAdByAdvertiserName", "uuid", "videoVariants"]
+
+    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 PrerollMediaInfo 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 call_to_action
+        if self.call_to_action:
+            _dict['callToAction'] = self.call_to_action.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of publisher_results
+        if self.publisher_results:
+            _dict['publisherResults'] = self.publisher_results.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in video_variants (list)
+        _items = []
+        if self.video_variants:
+            for _item_video_variants in self.video_variants:
+                _items.append(_item_video_variants.to_dict() if _item_video_variants is not None else None)
+            _dict['videoVariants'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PrerollMediaInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "advertiserName": obj.get("advertiserName"),
+            "advertiserProfileImageUrl": obj.get("advertiserProfileImageUrl"),
+            "callToAction": PrerollCallToAction.from_dict(obj["callToAction"]) if obj.get("callToAction") is not None else None,
+            "durationMillis": obj.get("durationMillis"),
+            "publisherResults": UserResults.from_dict(obj["publisherResults"]) if obj.get("publisherResults") is not None else None,
+            "renderAdByAdvertiserName": obj.get("renderAdByAdvertiserName"),
+            "uuid": obj.get("uuid"),
+            "videoVariants": [PrerollVideoVariant.from_dict(_item) for _item in obj["videoVariants"]] if obj.get("videoVariants") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/preroll_metadata.py

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

twitter_openapi_python_generated/models/preroll_video_variant.py

@@ -0,0 +1,93 @@
+# 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, StrictInt, 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 PrerollVideoVariant(BaseModel):
+    """
+    PrerollVideoVariant
+    """ # noqa: E501
+    bitrate: StrictInt
+    content_type: StrictStr = Field(alias="contentType")
+    url: StrictStr
+    __properties: ClassVar[List[str]] = ["bitrate", "contentType", "url"]
+
+    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 PrerollVideoVariant 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 PrerollVideoVariant from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "bitrate": obj.get("bitrate"),
+            "contentType": obj.get("contentType"),
+            "url": obj.get("url")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/rich_message_entity.py

@@ -18,8 +18,8 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictInt
-from typing import Any, ClassVar, Dict, List
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.rich_message_entity_ref import RichMessageEntityRef
 from typing import Optional, Set
 from typing_extensions import Self
@@ -29,10 +29,11 @@ class RichMessageEntity(BaseModel):
     """
     RichMessageEntity
     """ # noqa: E501
+    format: Optional[StrictStr] = None
     from_index: StrictInt = Field(alias="fromIndex")
-    ref: RichMessageEntityRef
+    ref: Optional[RichMessageEntityRef] = None
     to_index: StrictInt = Field(alias="toIndex")
-    __properties: ClassVar[List[str]] = ["fromIndex", "ref", "toIndex"]
+    __properties: ClassVar[List[str]] = ["format", "fromIndex", "ref", "toIndex"]
 
     model_config = ConfigDict(
         validate_by_name=True,
@@ -88,6 +89,7 @@ class RichMessageEntity(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "format": obj.get("format"),
             "fromIndex": obj.get("fromIndex"),
             "ref": RichMessageEntityRef.from_dict(obj["ref"]) if obj.get("ref") is not None else None,
             "toIndex": obj.get("toIndex")

twitter_openapi_python_generated/models/timeline_notification.py

@@ -22,8 +22,8 @@ from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.content_item_type import ContentItemType
 from twitter_openapi_python_generated.models.notification_template import NotificationTemplate
+from twitter_openapi_python_generated.models.notification_url import NotificationUrl
 from twitter_openapi_python_generated.models.rich_message import RichMessage
-from twitter_openapi_python_generated.models.social_context_landing_url import SocialContextLandingUrl
 from twitter_openapi_python_generated.models.type_name import TypeName
 from typing import Optional, Set
 from typing_extensions import Self
@@ -37,7 +37,7 @@ class TimelineNotification(BaseModel):
     id: StrictStr
     item_type: ContentItemType = Field(alias="itemType")
     notification_icon: StrictStr
-    notification_url: SocialContextLandingUrl
+    notification_url: NotificationUrl
     rich_message: RichMessage
     template: NotificationTemplate
     timestamp_ms: StrictStr
@@ -107,7 +107,7 @@ class TimelineNotification(BaseModel):
             "id": obj.get("id"),
             "itemType": obj.get("itemType"),
             "notification_icon": obj.get("notification_icon"),
-            "notification_url": SocialContextLandingUrl.from_dict(obj["notification_url"]) if obj.get("notification_url") is not None else None,
+            "notification_url": NotificationUrl.from_dict(obj["notification_url"]) if obj.get("notification_url") is not None else None,
             "rich_message": RichMessage.from_dict(obj["rich_message"]) if obj.get("rich_message") is not None else None,
             "template": NotificationTemplate.from_dict(obj["template"]) if obj.get("template") is not None else None,
             "timestamp_ms": obj.get("timestamp_ms")

twitter_openapi_python_generated/models/timeline_tweet.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.content_item_type import ContentItemType
 from twitter_openapi_python_generated.models.highlight import Highlight
 from twitter_openapi_python_generated.models.item_result import ItemResult
+from twitter_openapi_python_generated.models.preroll_metadata import PrerollMetadata
 from twitter_openapi_python_generated.models.promoted_metadata import PromotedMetadata
 from twitter_openapi_python_generated.models.social_context_union import SocialContextUnion
 from twitter_openapi_python_generated.models.type_name import TypeName
@@ -38,11 +39,12 @@ class TimelineTweet(BaseModel):
     has_moderated_replies: Optional[StrictBool] = Field(default=None, alias="hasModeratedReplies")
     highlights: Optional[Highlight] = None
     item_type: ContentItemType = Field(alias="itemType")
+    preroll_metadata: Optional[PrerollMetadata] = Field(default=None, alias="prerollMetadata")
     promoted_metadata: Optional[PromotedMetadata] = Field(default=None, alias="promotedMetadata")
     social_context: Optional[SocialContextUnion] = Field(default=None, alias="socialContext")
     tweet_display_type: StrictStr = Field(alias="tweetDisplayType")
     tweet_results: ItemResult
-    __properties: ClassVar[List[str]] = ["__typename", "hasModeratedReplies", "highlights", "itemType", "promotedMetadata", "socialContext", "tweetDisplayType", "tweet_results"]
+    __properties: ClassVar[List[str]] = ["__typename", "hasModeratedReplies", "highlights", "itemType", "prerollMetadata", "promotedMetadata", "socialContext", "tweetDisplayType", "tweet_results"]
 
     @field_validator('tweet_display_type')
     def tweet_display_type_validate_enum(cls, value):
@@ -93,6 +95,9 @@ class TimelineTweet(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of highlights
         if self.highlights:
             _dict['highlights'] = self.highlights.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of preroll_metadata
+        if self.preroll_metadata:
+            _dict['prerollMetadata'] = self.preroll_metadata.to_dict()
         # override the default output from pydantic by calling `to_dict()` of promoted_metadata
         if self.promoted_metadata:
             _dict['promotedMetadata'] = self.promoted_metadata.to_dict()
@@ -118,6 +123,7 @@ class TimelineTweet(BaseModel):
             "hasModeratedReplies": obj.get("hasModeratedReplies"),
             "highlights": Highlight.from_dict(obj["highlights"]) if obj.get("highlights") is not None else None,
             "itemType": obj.get("itemType"),
+            "prerollMetadata": PrerollMetadata.from_dict(obj["prerollMetadata"]) if obj.get("prerollMetadata") is not None else None,
             "promotedMetadata": PromotedMetadata.from_dict(obj["promotedMetadata"]) if obj.get("promotedMetadata") is not None else None,
             "socialContext": SocialContextUnion.from_dict(obj["socialContext"]) if obj.get("socialContext") is not None else None,
             "tweetDisplayType": obj.get("tweetDisplayType"),

twitter_openapi_python_generated/models/tweet.py

@@ -39,6 +39,7 @@ from twitter_openapi_python_generated.models.tweet_edit_control import TweetEdit
 from twitter_openapi_python_generated.models.tweet_edit_prespective import TweetEditPrespective
 from twitter_openapi_python_generated.models.tweet_post_cta import TweetPostCta
 from twitter_openapi_python_generated.models.tweet_previous_counts import TweetPreviousCounts
+from twitter_openapi_python_generated.models.tweet_sports_post_context import TweetSportsPostContext
 from twitter_openapi_python_generated.models.tweet_view import TweetView
 from twitter_openapi_python_generated.models.type_name import TypeName
 from twitter_openapi_python_generated.models.unified_card import UnifiedCard
@@ -83,13 +84,14 @@ class Tweet(BaseModel):
     quoted_status_result: Optional[ItemResult] = None
     rest_id: Annotated[str, Field(strict=True)]
     source: Optional[StrictStr] = None
+    sports_post_context: Optional[TweetSportsPostContext] = None
     super_follows_reply_user_result: Optional[SuperFollowsReplyUserResult] = Field(default=None, alias="superFollowsReplyUserResult")
     trend_results: Optional[TrendResults] = None
     unified_card: Optional[UnifiedCard] = None
     unmention_data: Optional[Dict[str, Any]] = None
     views: Optional[TweetView] = None
     voice_info: Optional[Dict[str, Any]] = Field(default=None, alias="voiceInfo")
-    __properties: ClassVar[List[str]] = ["__typename", "article", "author_community_relationship", "birdwatch_pivot", "card", "cashtag_attachments", "community_relationship", "community_results", "content_disclosure", "core", "edit_control", "edit_prespective", "grok_analysis_button", "grok_analysis_followups", "grok_annotations", "grok_share_attachment", "grok_translated_post_with_availability", "has_birdwatch_notes", "is_translatable", "jetfuel_attachment", "legacy", "nested_quoted_tweet_results", "note_tweet", "postCta", "post_image_description", "post_video_description", "previous_counts", "quick_promote_eligibility", "quotedRefResult", "quoted_status_result", "rest_id", "source", "superFollowsReplyUserResult", "trend_results", "unified_card", "unmention_data", "views", "voiceInfo"]
+    __properties: ClassVar[List[str]] = ["__typename", "article", "author_community_relationship", "birdwatch_pivot", "card", "cashtag_attachments", "community_relationship", "community_results", "content_disclosure", "core", "edit_control", "edit_prespective", "grok_analysis_button", "grok_analysis_followups", "grok_annotations", "grok_share_attachment", "grok_translated_post_with_availability", "has_birdwatch_notes", "is_translatable", "jetfuel_attachment", "legacy", "nested_quoted_tweet_results", "note_tweet", "postCta", "post_image_description", "post_video_description", "previous_counts", "quick_promote_eligibility", "quotedRefResult", "quoted_status_result", "rest_id", "source", "sports_post_context", "superFollowsReplyUserResult", "trend_results", "unified_card", "unmention_data", "views", "voiceInfo"]
 
     @field_validator('rest_id', mode="before")
     def rest_id_validate_regular_expression(cls, value):
@@ -206,6 +208,9 @@ class Tweet(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of quoted_status_result
         if self.quoted_status_result:
             _dict['quoted_status_result'] = self.quoted_status_result.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of sports_post_context
+        if self.sports_post_context:
+            _dict['sports_post_context'] = self.sports_post_context.to_dict()
         # override the default output from pydantic by calling `to_dict()` of super_follows_reply_user_result
         if self.super_follows_reply_user_result:
             _dict['superFollowsReplyUserResult'] = self.super_follows_reply_user_result.to_dict()
@@ -262,6 +267,7 @@ class Tweet(BaseModel):
             "quoted_status_result": ItemResult.from_dict(obj["quoted_status_result"]) if obj.get("quoted_status_result") is not None else None,
             "rest_id": obj.get("rest_id"),
             "source": obj.get("source"),
+            "sports_post_context": TweetSportsPostContext.from_dict(obj["sports_post_context"]) if obj.get("sports_post_context") is not None else None,
             "superFollowsReplyUserResult": SuperFollowsReplyUserResult.from_dict(obj["superFollowsReplyUserResult"]) if obj.get("superFollowsReplyUserResult") is not None else None,
             "trend_results": TrendResults.from_dict(obj["trend_results"]) if obj.get("trend_results") is not None else None,
             "unified_card": UnifiedCard.from_dict(obj["unified_card"]) if obj.get("unified_card") is not None else None,