twitter-openapi-python-generated 0.0.16__py3-none-any.whl → 0.0.18__py3-none-any.whl

twitter_openapi_python_generated/models/post_favorite_tweet_request.py

@@ -20,7 +20,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List
-from twitter_openapi_python_generated.models.post_create_retweet_request_variables import PostCreateRetweetRequestVariables
+from twitter_openapi_python_generated.models.post_create_bookmark_request_variables import PostCreateBookmarkRequestVariables
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,7 +29,7 @@ class PostFavoriteTweetRequest(BaseModel):
     PostFavoriteTweetRequest
     """ # noqa: E501
     query_id: StrictStr = Field(alias="queryId")
-    variables: PostCreateRetweetRequestVariables
+    variables: PostCreateBookmarkRequestVariables
     __properties: ClassVar[List[str]] = ["queryId", "variables"]
 
     model_config = ConfigDict(
@@ -87,7 +87,7 @@ class PostFavoriteTweetRequest(BaseModel):
 
         _obj = cls.model_validate({
             "queryId": obj.get("queryId") if obj.get("queryId") is not None else 'lI07N6Otwv1PhnEgXILM7A',
-            "variables": PostCreateRetweetRequestVariables.from_dict(obj["variables"]) if obj.get("variables") is not None else None
+            "variables": PostCreateBookmarkRequestVariables.from_dict(obj["variables"]) if obj.get("variables") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/sensitive_media_warning.py

@@ -83,9 +83,9 @@ class SensitiveMediaWarning(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "adult_content": obj.get("adult_content") if obj.get("adult_content") is not None else False,
-            "graphic_violence": obj.get("graphic_violence") if obj.get("graphic_violence") is not None else False,
-            "other": obj.get("other") if obj.get("other") is not None else False
+            "adult_content": obj.get("adult_content"),
+            "graphic_violence": obj.get("graphic_violence"),
+            "other": obj.get("other")
         })
         return _obj
 

twitter_openapi_python_generated/models/text.py

@@ -74,9 +74,9 @@ class Text(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in entities (list)
         _items = []
         if self.entities:
-            for _item in self.entities:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_entities in self.entities:
+                if _item_entities:
+                    _items.append(_item_entities.to_dict())
             _dict['entities'] = _items
         return _dict
 

twitter_openapi_python_generated/models/timeline.py

@@ -75,9 +75,9 @@ class Timeline(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in instructions (list)
         _items = []
         if self.instructions:
-            for _item in self.instructions:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_instructions in self.instructions:
+                if _item_instructions:
+                    _items.append(_item_instructions.to_dict())
             _dict['instructions'] = _items
         return _dict
 

twitter_openapi_python_generated/models/timeline_add_entries.py

@@ -75,9 +75,9 @@ class TimelineAddEntries(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in entries (list)
         _items = []
         if self.entries:
-            for _item in self.entries:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_entries in self.entries:
+                if _item_entries:
+                    _items.append(_item_entries.to_dict())
             _dict['entries'] = _items
         return _dict
 

twitter_openapi_python_generated/models/timeline_add_to_module.py

@@ -77,9 +77,9 @@ class TimelineAddToModule(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in module_items (list)
         _items = []
         if self.module_items:
-            for _item in self.module_items:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_module_items in self.module_items:
+                if _item_module_items:
+                    _items.append(_item_module_items.to_dict())
             _dict['moduleItems'] = _items
         return _dict
 

twitter_openapi_python_generated/models/timeline_cover_behavior.py

@@ -19,7 +19,8 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
+from twitter_openapi_python_generated.models.timeline_cover_behavior_url import TimelineCoverBehaviorUrl
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -28,13 +29,14 @@ class TimelineCoverBehavior(BaseModel):
     TimelineCoverBehavior
     """ # noqa: E501
     type: StrictStr
-    __properties: ClassVar[List[str]] = ["type"]
+    url: Optional[TimelineCoverBehaviorUrl] = None
+    __properties: ClassVar[List[str]] = ["type", "url"]
 
     @field_validator('type')
     def type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in set(['TimelineCoverBehaviorDismiss']):
-            raise ValueError("must be one of enum values ('TimelineCoverBehaviorDismiss')")
+        if value not in set(['TimelineCoverBehaviorDismiss', 'TimelineCoverBehaviorNavigate']):
+            raise ValueError("must be one of enum values ('TimelineCoverBehaviorDismiss', 'TimelineCoverBehaviorNavigate')")
         return value
 
     model_config = ConfigDict(
@@ -76,6 +78,9 @@ class TimelineCoverBehavior(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of url
+        if self.url:
+            _dict['url'] = self.url.to_dict()
         return _dict
 
     @classmethod
@@ -88,7 +93,8 @@ class TimelineCoverBehavior(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "type": obj.get("type")
+            "type": obj.get("type"),
+            "url": TimelineCoverBehaviorUrl.from_dict(obj["url"]) if obj.get("url") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/{extensions.py → timeline_cover_behavior_url.py}

@@ -18,22 +18,25 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List
-from twitter_openapi_python_generated.models.tracing import Tracing
 from typing import Optional, Set
 from typing_extensions import Self
 
-class Extensions(BaseModel):
+class TimelineCoverBehaviorUrl(BaseModel):
     """
-    Extensions
+    TimelineCoverBehaviorUrl
     """ # noqa: E501
-    code: StrictInt
-    kind: StrictStr
-    name: StrictStr
-    source: StrictStr
-    tracing: Tracing
-    __properties: ClassVar[List[str]] = ["code", "kind", "name", "source", "tracing"]
+    url: StrictStr
+    url_type: StrictStr
+    __properties: ClassVar[List[str]] = ["url", "url_type"]
+
+    @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 = ConfigDict(
         populate_by_name=True,
@@ -53,7 +56,7 @@ class Extensions(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of Extensions from a JSON string"""
+        """Create an instance of TimelineCoverBehaviorUrl from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -74,14 +77,11 @@ class Extensions(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of tracing
-        if self.tracing:
-            _dict['tracing'] = self.tracing.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of Extensions from a dict"""
+        """Create an instance of TimelineCoverBehaviorUrl from a dict"""
         if obj is None:
             return None
 
@@ -89,11 +89,8 @@ class Extensions(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "code": obj.get("code"),
-            "kind": obj.get("kind"),
-            "name": obj.get("name"),
-            "source": obj.get("source"),
-            "tracing": Tracing.from_dict(obj["tracing"]) if obj.get("tracing") is not None else None
+            "url": obj.get("url"),
+            "url_type": obj.get("url_type")
         })
         return _obj
 

twitter_openapi_python_generated/models/timeline_half_cover.py

@@ -95,9 +95,9 @@ class TimelineHalfCover(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in impression_callbacks (list)
         _items = []
         if self.impression_callbacks:
-            for _item in self.impression_callbacks:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_impression_callbacks in self.impression_callbacks:
+                if _item_impression_callbacks:
+                    _items.append(_item_impression_callbacks.to_dict())
             _dict['impressionCallbacks'] = _items
         # override the default output from pydantic by calling `to_dict()` of primary_cover_cta
         if self.primary_cover_cta:

twitter_openapi_python_generated/models/timeline_show_alert.py

@@ -106,9 +106,9 @@ class TimelineShowAlert(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in users_results (list)
         _items = []
         if self.users_results:
-            for _item in self.users_results:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_users_results in self.users_results:
+                if _item_users_results:
+                    _items.append(_item_users_results.to_dict())
             _dict['usersResults'] = _items
         return _dict
 

twitter_openapi_python_generated/models/timeline_timeline_cursor.py

@@ -36,7 +36,7 @@ class TimelineTimelineCursor(BaseModel):
     display_treatment: Optional[DisplayTreatment] = Field(default=None, alias="displayTreatment")
     entry_type: Optional[ContentEntryType] = Field(default=None, alias="entryType")
     item_type: Optional[ContentEntryType] = Field(default=None, alias="itemType")
-    stop_on_empty_response: StrictBool = Field(alias="stopOnEmptyResponse")
+    stop_on_empty_response: Optional[StrictBool] = Field(default=None, alias="stopOnEmptyResponse")
     value: StrictStr
     __properties: ClassVar[List[str]] = ["__typename", "cursorType", "displayTreatment", "entryType", "itemType", "stopOnEmptyResponse", "value"]
 
@@ -99,7 +99,7 @@ class TimelineTimelineCursor(BaseModel):
             "displayTreatment": DisplayTreatment.from_dict(obj["displayTreatment"]) if obj.get("displayTreatment") is not None else None,
             "entryType": obj.get("entryType"),
             "itemType": obj.get("itemType"),
-            "stopOnEmptyResponse": obj.get("stopOnEmptyResponse") if obj.get("stopOnEmptyResponse") is not None else False,
+            "stopOnEmptyResponse": obj.get("stopOnEmptyResponse"),
             "value": obj.get("value")
         })
         return _obj

twitter_openapi_python_generated/models/timeline_timeline_module.py

@@ -87,9 +87,9 @@ class TimelineTimelineModule(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in items (list)
         _items = []
         if self.items:
-            for _item in self.items:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_items in self.items:
+                if _item_items:
+                    _items.append(_item_items.to_dict())
             _dict['items'] = _items
         return _dict
 

twitter_openapi_python_generated/models/timeline_v2.py

@@ -19,7 +19,7 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.timeline import Timeline
 from typing import Optional, Set
 from typing_extensions import Self
@@ -28,7 +28,7 @@ class TimelineV2(BaseModel):
     """
     TimelineV2
     """ # noqa: E501
-    timeline: Timeline
+    timeline: Optional[Timeline] = None
     __properties: ClassVar[List[str]] = ["timeline"]
 
     model_config = ConfigDict(

twitter_openapi_python_generated/models/tweet.py

@@ -24,6 +24,7 @@ from typing_extensions import Annotated
 from twitter_openapi_python_generated.models.article import Article
 from twitter_openapi_python_generated.models.author_community_relationship import AuthorCommunityRelationship
 from twitter_openapi_python_generated.models.birdwatch_pivot import BirdwatchPivot
+from twitter_openapi_python_generated.models.community import Community
 from twitter_openapi_python_generated.models.note_tweet import NoteTweet
 from twitter_openapi_python_generated.models.super_follows_reply_user_result import SuperFollowsReplyUserResult
 from twitter_openapi_python_generated.models.tweet_card import TweetCard
@@ -46,11 +47,12 @@ class Tweet(BaseModel):
     author_community_relationship: Optional[AuthorCommunityRelationship] = None
     birdwatch_pivot: Optional[BirdwatchPivot] = None
     card: Optional[TweetCard] = None
+    community_results: Optional[Community] = None
     core: Optional[UserResultCore] = None
     edit_control: Optional[TweetEditControl] = None
     edit_prespective: Optional[TweetEditPrespective] = None
     has_birdwatch_notes: Optional[StrictBool] = None
-    is_translatable: Optional[StrictBool] = False
+    is_translatable: Optional[StrictBool] = None
     legacy: Optional[TweetLegacy] = None
     note_tweet: Optional[NoteTweet] = None
     previous_counts: Optional[TweetPreviousCounts] = None
@@ -63,7 +65,7 @@ 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", "core", "edit_control", "edit_prespective", "has_birdwatch_notes", "is_translatable", "legacy", "note_tweet", "previous_counts", "quick_promote_eligibility", "quotedRefResult", "quoted_status_result", "rest_id", "source", "superFollowsReplyUserResult", "unified_card", "unmention_data", "views"]
+    __properties: ClassVar[List[str]] = ["__typename", "article", "author_community_relationship", "birdwatch_pivot", "card", "community_results", "core", "edit_control", "edit_prespective", "has_birdwatch_notes", "is_translatable", "legacy", "note_tweet", "previous_counts", "quick_promote_eligibility", "quotedRefResult", "quoted_status_result", "rest_id", "source", "superFollowsReplyUserResult", "unified_card", "unmention_data", "views"]
 
     @field_validator('rest_id')
     def rest_id_validate_regular_expression(cls, value):
@@ -123,6 +125,9 @@ class Tweet(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of card
         if self.card:
             _dict['card'] = self.card.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of community_results
+        if self.community_results:
+            _dict['community_results'] = self.community_results.to_dict()
         # override the default output from pydantic by calling `to_dict()` of core
         if self.core:
             _dict['core'] = self.core.to_dict()
@@ -173,11 +178,12 @@ class Tweet(BaseModel):
             "author_community_relationship": AuthorCommunityRelationship.from_dict(obj["author_community_relationship"]) if obj.get("author_community_relationship") is not None else None,
             "birdwatch_pivot": BirdwatchPivot.from_dict(obj["birdwatch_pivot"]) if obj.get("birdwatch_pivot") is not None else None,
             "card": TweetCard.from_dict(obj["card"]) if obj.get("card") is not None else None,
+            "community_results": Community.from_dict(obj["community_results"]) if obj.get("community_results") is not None else None,
             "core": UserResultCore.from_dict(obj["core"]) if obj.get("core") is not None else None,
             "edit_control": TweetEditControl.from_dict(obj["edit_control"]) if obj.get("edit_control") is not None else None,
             "edit_prespective": TweetEditPrespective.from_dict(obj["edit_prespective"]) if obj.get("edit_prespective") is not None else None,
             "has_birdwatch_notes": obj.get("has_birdwatch_notes"),
-            "is_translatable": obj.get("is_translatable") if obj.get("is_translatable") is not None else False,
+            "is_translatable": obj.get("is_translatable"),
             "legacy": TweetLegacy.from_dict(obj["legacy"]) if obj.get("legacy") is not None else None,
             "note_tweet": NoteTweet.from_dict(obj["note_tweet"]) if obj.get("note_tweet") is not None else None,
             "previous_counts": TweetPreviousCounts.from_dict(obj["previous_counts"]) if obj.get("previous_counts") is not None else None,

twitter_openapi_python_generated/models/tweet_card_legacy.py

@@ -79,9 +79,9 @@ class TweetCardLegacy(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in binding_values (list)
         _items = []
         if self.binding_values:
-            for _item in self.binding_values:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_binding_values in self.binding_values:
+                if _item_binding_values:
+                    _items.append(_item_binding_values.to_dict())
             _dict['binding_values'] = _items
         # override the default output from pydantic by calling `to_dict()` of card_platform
         if self.card_platform:
@@ -89,9 +89,9 @@ class TweetCardLegacy(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in user_refs_results (list)
         _items = []
         if self.user_refs_results:
-            for _item in self.user_refs_results:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_user_refs_results in self.user_refs_results:
+                if _item_user_refs_results:
+                    _items.append(_item_user_refs_results.to_dict())
             _dict['user_refs_results'] = _items
         return _dict
 

twitter_openapi_python_generated/models/tweet_interstitial_reveal_text.py

@@ -75,9 +75,9 @@ class TweetInterstitialRevealText(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in entities (list)
         _items = []
         if self.entities:
-            for _item in self.entities:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_entities in self.entities:
+                if _item_entities:
+                    _items.append(_item_entities.to_dict())
             _dict['entities'] = _items
         return _dict
 

twitter_openapi_python_generated/models/tweet_interstitial_text.py

@@ -75,9 +75,9 @@ class TweetInterstitialText(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in entities (list)
         _items = []
         if self.entities:
-            for _item in self.entities:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_entities in self.entities:
+                if _item_entities:
+                    _items.append(_item_entities.to_dict())
             _dict['entities'] = _items
         return _dict
 

twitter_openapi_python_generated/models/tweet_legacy.py

@@ -52,8 +52,8 @@ class TweetLegacy(BaseModel):
     lang: StrictStr
     limited_actions: Optional[StrictStr] = None
     place: Optional[Dict[str, Any]] = None
-    possibly_sensitive: Optional[StrictBool] = False
-    possibly_sensitive_editable: Optional[StrictBool] = False
+    possibly_sensitive: Optional[StrictBool] = None
+    possibly_sensitive_editable: Optional[StrictBool] = None
     quote_count: StrictInt
     quoted_status_id_str: Optional[Annotated[str, Field(strict=True)]] = None
     quoted_status_permalink: Optional[QuotedStatusPermalink] = None
@@ -222,8 +222,8 @@ class TweetLegacy(BaseModel):
             "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,
+            "possibly_sensitive": obj.get("possibly_sensitive"),
+            "possibly_sensitive_editable": obj.get("possibly_sensitive_editable"),
             "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,

twitter_openapi_python_generated/models/{error_response.py → tweet_unavailable.py}

@@ -18,18 +18,19 @@ 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.errors import Errors
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from twitter_openapi_python_generated.models.type_name import TypeName
 from typing import Optional, Set
 from typing_extensions import Self
 
-class ErrorResponse(BaseModel):
+class TweetUnavailable(BaseModel):
     """
-    ErrorResponse
+    TweetUnavailable
     """ # noqa: E501
-    errors: Errors
-    __properties: ClassVar[List[str]] = ["errors"]
+    typename: Optional[TypeName] = Field(default=None, alias="__typename")
+    reason: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["__typename", "reason"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -49,7 +50,7 @@ class ErrorResponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of ErrorResponse from a JSON string"""
+        """Create an instance of TweetUnavailable from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -70,14 +71,11 @@ class ErrorResponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of errors
-        if self.errors:
-            _dict['errors'] = self.errors.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of ErrorResponse from a dict"""
+        """Create an instance of TweetUnavailable from a dict"""
         if obj is None:
             return None
 
@@ -85,7 +83,8 @@ class ErrorResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "errors": Errors.from_dict(obj["errors"]) if obj.get("errors") is not None else None
+            "__typename": obj.get("__typename"),
+            "reason": obj.get("reason")
         })
         return _obj
 

twitter_openapi_python_generated/models/tweet_union.py

@@ -19,11 +19,12 @@ import pprint
 from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
 from typing import Any, List, Optional
 from twitter_openapi_python_generated.models.tweet_tombstone import TweetTombstone
+from twitter_openapi_python_generated.models.tweet_unavailable import TweetUnavailable
 from pydantic import StrictStr, Field
 from typing import Union, List, Set, Optional, Dict
 from typing_extensions import Literal, Self
 
-TWEETUNION_ONE_OF_SCHEMAS = ["Tweet", "TweetTombstone", "TweetWithVisibilityResults"]
+TWEETUNION_ONE_OF_SCHEMAS = ["Tweet", "TweetTombstone", "TweetUnavailable", "TweetWithVisibilityResults"]
 
 class TweetUnion(BaseModel):
     """
@@ -35,8 +36,10 @@ class TweetUnion(BaseModel):
     oneof_schema_2_validator: Optional[TweetWithVisibilityResults] = None
     # data type: TweetTombstone
     oneof_schema_3_validator: Optional[TweetTombstone] = None
-    actual_instance: Optional[Union[Tweet, TweetTombstone, TweetWithVisibilityResults]] = None
-    one_of_schemas: Set[str] = { "Tweet", "TweetTombstone", "TweetWithVisibilityResults" }
+    # data type: TweetUnavailable
+    oneof_schema_4_validator: Optional[TweetUnavailable] = None
+    actual_instance: Optional[Union[Tweet, TweetTombstone, TweetUnavailable, TweetWithVisibilityResults]] = None
+    one_of_schemas: Set[str] = { "Tweet", "TweetTombstone", "TweetUnavailable", "TweetWithVisibilityResults" }
 
     model_config = ConfigDict(
         validate_assignment=True,
@@ -77,12 +80,17 @@ class TweetUnion(BaseModel):
             error_messages.append(f"Error! Input type `{type(v)}` is not `TweetTombstone`")
         else:
             match += 1
+        # validate data type: TweetUnavailable
+        if not isinstance(v, TweetUnavailable):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `TweetUnavailable`")
+        else:
+            match += 1
         if match > 1:
             # more than 1 match
-            raise ValueError("Multiple matches found when setting `actual_instance` in TweetUnion with oneOf schemas: Tweet, TweetTombstone, TweetWithVisibilityResults. Details: " + ", ".join(error_messages))
+            raise ValueError("Multiple matches found when setting `actual_instance` in TweetUnion with oneOf schemas: Tweet, TweetTombstone, TweetUnavailable, TweetWithVisibilityResults. Details: " + ", ".join(error_messages))
         elif match == 0:
             # no match
-            raise ValueError("No match found when setting `actual_instance` in TweetUnion with oneOf schemas: Tweet, TweetTombstone, TweetWithVisibilityResults. Details: " + ", ".join(error_messages))
+            raise ValueError("No match found when setting `actual_instance` in TweetUnion with oneOf schemas: Tweet, TweetTombstone, TweetUnavailable, TweetWithVisibilityResults. Details: " + ", ".join(error_messages))
         else:
             return v
 
@@ -112,6 +120,11 @@ class TweetUnion(BaseModel):
             instance.actual_instance = TweetTombstone.from_json(json_str)
             return instance
 
+        # check if data type is `TweetUnavailable`
+        if _data_type == "TweetUnavailable":
+            instance.actual_instance = TweetUnavailable.from_json(json_str)
+            return instance
+
         # check if data type is `TweetWithVisibilityResults`
         if _data_type == "TweetWithVisibilityResults":
             instance.actual_instance = TweetWithVisibilityResults.from_json(json_str)
@@ -135,13 +148,19 @@ class TweetUnion(BaseModel):
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
+        # deserialize data into TweetUnavailable
+        try:
+            instance.actual_instance = TweetUnavailable.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
 
         if match > 1:
             # more than 1 match
-            raise ValueError("Multiple matches found when deserializing the JSON string into TweetUnion with oneOf schemas: Tweet, TweetTombstone, TweetWithVisibilityResults. Details: " + ", ".join(error_messages))
+            raise ValueError("Multiple matches found when deserializing the JSON string into TweetUnion with oneOf schemas: Tweet, TweetTombstone, TweetUnavailable, TweetWithVisibilityResults. Details: " + ", ".join(error_messages))
         elif match == 0:
             # no match
-            raise ValueError("No match found when deserializing the JSON string into TweetUnion with oneOf schemas: Tweet, TweetTombstone, TweetWithVisibilityResults. Details: " + ", ".join(error_messages))
+            raise ValueError("No match found when deserializing the JSON string into TweetUnion with oneOf schemas: Tweet, TweetTombstone, TweetUnavailable, TweetWithVisibilityResults. Details: " + ", ".join(error_messages))
         else:
             return instance
 
@@ -155,7 +174,7 @@ class TweetUnion(BaseModel):
         else:
             return json.dumps(self.actual_instance)
 
-    def to_dict(self) -> Optional[Union[Dict[str, Any], Tweet, TweetTombstone, TweetWithVisibilityResults]]:
+    def to_dict(self) -> Optional[Union[Dict[str, Any], Tweet, TweetTombstone, TweetUnavailable, TweetWithVisibilityResults]]:
         """Returns the dict representation of the actual instance"""
         if self.actual_instance is None:
             return None

twitter_openapi_python_generated/models/urt_endpoint_options.py

@@ -74,9 +74,9 @@ class UrtEndpointOptions(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in request_params (list)
         _items = []
         if self.request_params:
-            for _item in self.request_params:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_request_params in self.request_params:
+                if _item_request_params:
+                    _items.append(_item_request_params.to_dict())
             _dict['requestParams'] = _items
         return _dict