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

twitter_openapi_python_generated/models/timeline_half_cover.py

@@ -40,13 +40,6 @@ class TimelineHalfCover(BaseModel):
     type: StrictStr
     __properties: ClassVar[List[str]] = ["dismissible", "halfCoverDisplayType", "impressionCallbacks", "primaryCoverCta", "primaryText", "secondaryText", "type"]
 
-    @field_validator('half_cover_display_type')
-    def half_cover_display_type_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Cover']):
-            raise ValueError("must be one of enum values ('Cover')")
-        return value
-
     @field_validator('type')
     def type_validate_enum(cls, value):
         """Validates the enum"""

twitter_openapi_python_generated/models/timeline_message_prompt_content.py

@@ -18,7 +18,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.timeline_message_prompt_button import TimelineMessagePromptButton
 from twitter_openapi_python_generated.models.timeline_message_prompt_rich_text import TimelineMessagePromptRichText
@@ -37,13 +37,6 @@ class TimelineMessagePromptContent(BaseModel):
     primary_button_action: Optional[TimelineMessagePromptButton] = Field(default=None, alias="primaryButtonAction")
     __properties: ClassVar[List[str]] = ["bodyRichText", "bodyText", "contentType", "headerText", "primaryButtonAction"]
 
-    @field_validator('content_type')
-    def content_type_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['TimelineInlinePrompt', 'TimelineCompactPrompt']):
-            raise ValueError("must be one of enum values ('TimelineInlinePrompt', 'TimelineCompactPrompt')")
-        return value
-
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,

twitter_openapi_python_generated/models/timeline_prompt_content.py

@@ -18,7 +18,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.timeline_prompt_callback import TimelinePromptCallback
 from typing import Optional, Set
@@ -39,20 +39,6 @@ class TimelinePromptContent(BaseModel):
     title: StrictStr
     __properties: ClassVar[List[str]] = ["confirmation", "contentType", "displayType", "isRelevantCallback", "isRelevantText", "notRelevantCallback", "notRelevantText", "title"]
 
-    @field_validator('content_type')
-    def content_type_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['TimelineRelevancePrompt']):
-            raise ValueError("must be one of enum values ('TimelineRelevancePrompt')")
-        return value
-
-    @field_validator('display_type')
-    def display_type_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Compact']):
-            raise ValueError("must be one of enum values ('Compact')")
-        return value
-
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,

twitter_openapi_python_generated/models/timeline_show_alert.py

@@ -18,7 +18,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.client_event_info import ClientEventInfo
 from twitter_openapi_python_generated.models.instruction_type import InstructionType
@@ -46,20 +46,6 @@ class TimelineShowAlert(BaseModel):
     users_results: Optional[List[UserResults]] = Field(default=None, alias="usersResults")
     __properties: ClassVar[List[str]] = ["alertType", "clientEventInfo", "colorConfig", "displayDurationMs", "displayLocation", "iconDisplayInfo", "richText", "triggerDelayMs", "type", "usersResults"]
 
-    @field_validator('alert_type')
-    def alert_type_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['NewTweets']):
-            raise ValueError("must be one of enum values ('NewTweets')")
-        return value
-
-    @field_validator('display_location')
-    def display_location_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Top']):
-            raise ValueError("must be one of enum values ('Top')")
-        return value
-
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,

twitter_openapi_python_generated/models/timeline_tombstone.py

@@ -18,7 +18,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
 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.tombstone_info import TombstoneInfo
@@ -37,16 +37,6 @@ class TimelineTombstone(BaseModel):
     tombstone_info: Optional[TombstoneInfo] = Field(default=None, alias="tombstoneInfo")
     __properties: ClassVar[List[str]] = ["__typename", "itemType", "tombstoneDisplayType", "tombstoneInfo"]
 
-    @field_validator('tombstone_display_type')
-    def tombstone_display_type_validate_enum(cls, value):
-        """Validates the enum"""
-        if value is None:
-            return value
-
-        if value not in set(['Inline']):
-            raise ValueError("must be one of enum values ('Inline')")
-        return value
-
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,

twitter_openapi_python_generated/models/timeline_topic_context.py

@@ -18,7 +18,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.social_context_union_type import SocialContextUnionType
 from twitter_openapi_python_generated.models.topic_context import TopicContext
@@ -35,16 +35,6 @@ class TimelineTopicContext(BaseModel):
     type: Optional[SocialContextUnionType] = None
     __properties: ClassVar[List[str]] = ["functionalityType", "topic", "type"]
 
-    @field_validator('functionality_type')
-    def functionality_type_validate_enum(cls, value):
-        """Validates the enum"""
-        if value is None:
-            return value
-
-        if value not in set(['Basic']):
-            raise ValueError("must be one of enum values ('Basic')")
-        return value
-
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,

twitter_openapi_python_generated/models/tweet.py

@@ -88,7 +88,8 @@ class Tweet(BaseModel):
     unified_card: Optional[UnifiedCard] = None
     unmention_data: Optional[Dict[str, Any]] = None
     views: Optional[TweetView] = None
-    __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"]
+    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"]
 
     @field_validator('rest_id', mode="before")
     def rest_id_validate_regular_expression(cls, value):
@@ -265,7 +266,8 @@ class Tweet(BaseModel):
             "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,
             "unmention_data": obj.get("unmention_data"),
-            "views": TweetView.from_dict(obj["views"]) if obj.get("views") is not None else None
+            "views": TweetView.from_dict(obj["views"]) if obj.get("views") is not None else None,
+            "voiceInfo": obj.get("voiceInfo")
         })
         return _obj
 

twitter_openapi_python_generated/models/tweet_card_legacy_binding_value_data.py

@@ -18,7 +18,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.media_color_info import MediaColorInfo
 from twitter_openapi_python_generated.models.tweet_card_legacy_binding_value_data_image import TweetCardLegacyBindingValueDataImage
@@ -40,6 +40,13 @@ class TweetCardLegacyBindingValueData(BaseModel):
     user_value: Optional[UserValue] = None
     __properties: ClassVar[List[str]] = ["boolean_value", "image_color_value", "image_value", "scribe_key", "string_value", "type", "user_value"]
 
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['STRING', 'IMAGE', 'USER', 'BOOLEAN', 'IMAGE_COLOR']):
+            raise ValueError("must be one of enum values ('STRING', 'IMAGE', 'USER', 'BOOLEAN', 'IMAGE_COLOR')")
+        return value
+
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,

twitter_openapi_python_generated/models/tweet_card_platform_audience.py

@@ -18,7 +18,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, StrictStr
 from typing import Any, ClassVar, Dict, List
 from typing import Optional, Set
 from typing_extensions import Self
@@ -31,13 +31,6 @@ class TweetCardPlatformAudience(BaseModel):
     name: StrictStr
     __properties: ClassVar[List[str]] = ["name"]
 
-    @field_validator('name')
-    def name_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['production']):
-            raise ValueError("must be one of enum values ('production')")
-        return value
-
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,

twitter_openapi_python_generated/models/tweet_legacy.py

@@ -26,6 +26,8 @@ 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
+from twitter_openapi_python_generated.models.tweet_legacy_place import TweetLegacyPlace
+from twitter_openapi_python_generated.models.tweet_legacy_point import TweetLegacyPoint
 from twitter_openapi_python_generated.models.tweet_legacy_scopes import TweetLegacyScopes
 from typing import Optional, Set
 from typing_extensions import Self
@@ -39,6 +41,7 @@ class TweetLegacy(BaseModel):
     bookmarked: StrictBool
     conversation_control: Optional[ConversationControl] = None
     conversation_id_str: Annotated[str, Field(strict=True)]
+    coordinates: Optional[TweetLegacyPoint] = None
     created_at: Annotated[str, Field(strict=True)] = Field(json_schema_extra={"examples": ["Sat Dec 31 23:59:59 +0000 2023"]})
     display_text_range: List[StrictInt]
     entities: Optional[Entities] = None
@@ -46,6 +49,7 @@ class TweetLegacy(BaseModel):
     favorite_count: StrictInt
     favorited: StrictBool
     full_text: StrictStr
+    geo: Optional[TweetLegacyPoint] = None
     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
@@ -53,7 +57,7 @@ class TweetLegacy(BaseModel):
     is_quote_status: StrictBool
     lang: StrictStr
     limited_actions: Optional[StrictStr] = None
-    place: Optional[Dict[str, Any]] = None
+    place: Optional[TweetLegacyPlace] = None
     possibly_sensitive: Optional[StrictBool] = None
     possibly_sensitive_editable: Optional[StrictBool] = None
     quote_count: StrictInt
@@ -66,7 +70,7 @@ class TweetLegacy(BaseModel):
     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_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"]
+    __properties: ClassVar[List[str]] = ["bookmark_count", "bookmarked", "conversation_control", "conversation_id_str", "coordinates", "created_at", "display_text_range", "entities", "extended_entities", "favorite_count", "favorited", "full_text", "geo", "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', mode="before")
     def conversation_id_str_validate_regular_expression(cls, value):
@@ -178,12 +182,21 @@ class TweetLegacy(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of conversation_control
         if self.conversation_control:
             _dict['conversation_control'] = self.conversation_control.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of coordinates
+        if self.coordinates:
+            _dict['coordinates'] = self.coordinates.to_dict()
         # override the default output from pydantic by calling `to_dict()` of entities
         if self.entities:
             _dict['entities'] = self.entities.to_dict()
         # 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 geo
+        if self.geo:
+            _dict['geo'] = self.geo.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of place
+        if self.place:
+            _dict['place'] = self.place.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()
@@ -212,6 +225,7 @@ class TweetLegacy(BaseModel):
             "bookmarked": obj.get("bookmarked"),
             "conversation_control": ConversationControl.from_dict(obj["conversation_control"]) if obj.get("conversation_control") is not None else None,
             "conversation_id_str": obj.get("conversation_id_str"),
+            "coordinates": TweetLegacyPoint.from_dict(obj["coordinates"]) if obj.get("coordinates") is not None else None,
             "created_at": obj.get("created_at"),
             "display_text_range": obj.get("display_text_range"),
             "entities": Entities.from_dict(obj["entities"]) if obj.get("entities") is not None else None,
@@ -219,6 +233,7 @@ class TweetLegacy(BaseModel):
             "favorite_count": obj.get("favorite_count"),
             "favorited": obj.get("favorited"),
             "full_text": obj.get("full_text"),
+            "geo": TweetLegacyPoint.from_dict(obj["geo"]) if obj.get("geo") is not None else None,
             "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"),
@@ -226,7 +241,7 @@ class TweetLegacy(BaseModel):
             "is_quote_status": obj.get("is_quote_status"),
             "lang": obj.get("lang"),
             "limited_actions": obj.get("limited_actions"),
-            "place": obj.get("place"),
+            "place": TweetLegacyPlace.from_dict(obj["place"]) if obj.get("place") is not None else None,
             "possibly_sensitive": obj.get("possibly_sensitive"),
             "possibly_sensitive_editable": obj.get("possibly_sensitive_editable"),
             "quote_count": obj.get("quote_count"),

twitter_openapi_python_generated/models/tweet_legacy_place.py

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

twitter_openapi_python_generated/models/tweet_legacy_place_bounding_box.py

@@ -0,0 +1,98 @@
+# 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, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class TweetLegacyPlaceBoundingBox(BaseModel):
+    """
+    TweetLegacyPlaceBoundingBox
+    """ # noqa: E501
+    coordinates: List[List[List[Union[StrictFloat, StrictInt]]]]
+    type: StrictStr
+    __properties: ClassVar[List[str]] = ["coordinates", "type"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['Polygon']):
+            raise ValueError("must be one of enum values ('Polygon')")
+        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 TweetLegacyPlaceBoundingBox 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 TweetLegacyPlaceBoundingBox from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "coordinates": obj.get("coordinates"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/tweet_legacy_point.py

@@ -0,0 +1,98 @@
+# 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, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class TweetLegacyPoint(BaseModel):
+    """
+    TweetLegacyPoint
+    """ # noqa: E501
+    coordinates: List[Union[StrictFloat, StrictInt]]
+    type: StrictStr
+    __properties: ClassVar[List[str]] = ["coordinates", "type"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['Point']):
+            raise ValueError("must be one of enum values ('Point')")
+        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 TweetLegacyPoint 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 TweetLegacyPoint from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "coordinates": obj.get("coordinates"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/tweet_post_cta.py

@@ -18,7 +18,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.post_cta import PostCta
 from typing import Optional, Set
@@ -34,14 +34,6 @@ class TweetPostCta(BaseModel):
     scribe_id: Optional[StrictStr] = None
     __properties: ClassVar[List[str]] = ["display_locations", "post_cta", "scribe_id"]
 
-    @field_validator('display_locations')
-    def display_locations_validate_enum(cls, value):
-        """Validates the enum"""
-        for i in value:
-            if i not in set(['TweetDetails', 'ForYouTimeline', 'RepliesTimeline']):
-                raise ValueError("each list item must be one of ('TweetDetails', 'ForYouTimeline', 'RepliesTimeline')")
-        return value
-
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,

twitter_openapi_python_generated/models/type_name.py

@@ -33,6 +33,7 @@ class TypeName(str, Enum):
     TIMELINETWITTERLIST = 'TimelineTwitterList'
     TIMELINELABEL = 'TimelineLabel'
     TIMELINEEVENTSUMMARY = 'TimelineEventSummary'
+    AITREND = 'AiTrend'
     TIMELINETIMELINEITEM = 'TimelineTimelineItem'
     TIMELINEUSER = 'TimelineUser'
     TIMELINETIMELINECURSOR = 'TimelineTimelineCursor'