twitter-openapi-python-generated 0.0.33__py3-none-any.whl → 0.0.35__py3-none-any.whl

twitter_openapi_python_generated/models/tombstone_rich_text.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.tombstone_entity import TombstoneEntity
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TombstoneRichText(BaseModel):
     """
@@ -34,7 +35,8 @@ class TombstoneRichText(BaseModel):
     __properties: ClassVar[List[str]] = ["entities", "rtl", "text"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -46,8 +48,7 @@ class TombstoneRichText(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
@@ -76,8 +77,7 @@ class TombstoneRichText(BaseModel):
         _items = []
         if self.entities:
             for _item_entities in self.entities:
-                if _item_entities:
-                    _items.append(_item_entities.to_dict())
+                _items.append(_item_entities.to_dict() if _item_entities is not None else None)
             _dict['entities'] = _items
         return _dict
 

twitter_openapi_python_generated/models/topic_context.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TopicContext(BaseModel):
     """
@@ -37,7 +38,8 @@ class TopicContext(BaseModel):
     __properties: ClassVar[List[str]] = ["description", "following", "icon_url", "id", "name", "not_interested", "topic_id"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -49,8 +51,7 @@ class TopicContext(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/tracing.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from typing_extensions import Annotated
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class Tracing(BaseModel):
     """
@@ -31,15 +32,16 @@ class Tracing(BaseModel):
     trace_id: Annotated[str, Field(strict=True)]
     __properties: ClassVar[List[str]] = ["trace_id"]
 
-    @field_validator('trace_id')
+    @field_validator('trace_id', mode="before")
     def trace_id_validate_regular_expression(cls, value):
         """Validates the regular expression"""
-        if not re.match(r"^[0-9a-f]{16}$", value):
+        if isinstance(value, str) and not re.match(r"^[0-9a-f]{16}$", value):
             raise ValueError(r"must validate the regular expression /^[0-9a-f]{16}$/")
         return value
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -51,8 +53,7 @@ class Tracing(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/trend_image.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TrendImage(BaseModel):
     """
@@ -31,7 +32,8 @@ class TrendImage(BaseModel):
     __properties: ClassVar[List[str]] = ["url"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -43,8 +45,7 @@ class TrendImage(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/trend_metadata.py

@@ -18,21 +18,24 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.social_context_landing_url import SocialContextLandingUrl
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TrendMetadata(BaseModel):
     """
     TrendMetadata
     """ # noqa: E501
+    domain_context: Optional[StrictStr] = None
     url: Optional[SocialContextLandingUrl] = None
-    __properties: ClassVar[List[str]] = ["url"]
+    __properties: ClassVar[List[str]] = ["domain_context", "url"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -44,8 +47,7 @@ class TrendMetadata(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
@@ -85,6 +87,7 @@ class TrendMetadata(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "domain_context": obj.get("domain_context"),
             "url": SocialContextLandingUrl.from_dict(obj["url"]) if obj.get("url") is not None else None
         })
         return _obj

twitter_openapi_python_generated/models/trend_results.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from typing_extensions import Annotated
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TrendResults(BaseModel):
     """
@@ -31,15 +32,16 @@ class TrendResults(BaseModel):
     rest_id: Annotated[str, Field(strict=True)]
     __properties: ClassVar[List[str]] = ["rest_id"]
 
-    @field_validator('rest_id')
+    @field_validator('rest_id', mode="before")
     def rest_id_validate_regular_expression(cls, value):
         """Validates the regular expression"""
-        if not re.match(r"^[0-9]+$", value):
+        if isinstance(value, str) and not re.match(r"^[0-9]+$", value):
             raise ValueError(r"must validate the regular expression /^[0-9]+$/")
         return value
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -51,8 +53,7 @@ class TrendResults(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/tweet.py

@@ -24,14 +24,19 @@ 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.cashtag_attachment import CashtagAttachment
 from twitter_openapi_python_generated.models.community_relationship import CommunityRelationship
+from twitter_openapi_python_generated.models.community_result import CommunityResult
+from twitter_openapi_python_generated.models.content_disclosure import ContentDisclosure
+from twitter_openapi_python_generated.models.grok_annotation import GrokAnnotation
+from twitter_openapi_python_generated.models.grok_translated_post_with_availability import GrokTranslatedPostWithAvailability
 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.trend_results import TrendResults
 from twitter_openapi_python_generated.models.tweet_card import TweetCard
 from twitter_openapi_python_generated.models.tweet_edit_control import TweetEditControl
 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_view import TweetView
 from twitter_openapi_python_generated.models.type_name import TypeName
@@ -39,6 +44,7 @@ from twitter_openapi_python_generated.models.unified_card import UnifiedCard
 from twitter_openapi_python_generated.models.user_result_core import UserResultCore
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class Tweet(BaseModel):
     """
@@ -49,18 +55,26 @@ class Tweet(BaseModel):
     author_community_relationship: Optional[AuthorCommunityRelationship] = None
     birdwatch_pivot: Optional[BirdwatchPivot] = None
     card: Optional[TweetCard] = None
+    cashtag_attachments: Optional[List[CashtagAttachment]] = None
     community_relationship: Optional[CommunityRelationship] = None
-    community_results: Optional[Community] = None
+    community_results: Optional[CommunityResult] = None
+    content_disclosure: Optional[ContentDisclosure] = None
     core: Optional[UserResultCore] = None
     edit_control: Optional[TweetEditControl] = None
     edit_prespective: Optional[TweetEditPrespective] = None
     grok_analysis_button: Optional[StrictBool] = None
     grok_analysis_followups: Optional[List[StrictStr]] = None
+    grok_annotations: Optional[GrokAnnotation] = None
     grok_share_attachment: Optional[GrokShareAttachment] = None
+    grok_translated_post_with_availability: Optional[GrokTranslatedPostWithAvailability] = None
     has_birdwatch_notes: Optional[StrictBool] = None
     is_translatable: Optional[StrictBool] = None
     legacy: Optional[TweetLegacy] = None
+    nested_quoted_tweet_results: Optional[ItemResult] = None
     note_tweet: Optional[NoteTweet] = None
+    post_cta: Optional[TweetPostCta] = Field(default=None, alias="postCta")
+    post_image_description: Optional[StrictStr] = None
+    post_video_description: Optional[StrictStr] = None
     previous_counts: Optional[TweetPreviousCounts] = None
     quick_promote_eligibility: Optional[Dict[str, Any]] = None
     quoted_ref_result: Optional[QuotedRefResult] = Field(default=None, alias="quotedRefResult")
@@ -72,17 +86,18 @@ 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", "community_relationship", "community_results", "core", "edit_control", "edit_prespective", "grok_analysis_button", "grok_analysis_followups", "grok_share_attachment", "has_birdwatch_notes", "is_translatable", "legacy", "note_tweet", "previous_counts", "quick_promote_eligibility", "quotedRefResult", "quoted_status_result", "rest_id", "source", "superFollowsReplyUserResult", "trend_results", "unified_card", "unmention_data", "views"]
+    __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", "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"]
 
-    @field_validator('rest_id')
+    @field_validator('rest_id', mode="before")
     def rest_id_validate_regular_expression(cls, value):
         """Validates the regular expression"""
-        if not re.match(r"^[0-9]+$", value):
+        if isinstance(value, str) and not re.match(r"^[0-9]+$", value):
             raise ValueError(r"must validate the regular expression /^[0-9]+$/")
         return value
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -94,8 +109,7 @@ class Tweet(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
@@ -132,12 +146,21 @@ 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 each item in cashtag_attachments (list)
+        _items = []
+        if self.cashtag_attachments:
+            for _item_cashtag_attachments in self.cashtag_attachments:
+                _items.append(_item_cashtag_attachments.to_dict() if _item_cashtag_attachments is not None else None)
+            _dict['cashtag_attachments'] = _items
         # override the default output from pydantic by calling `to_dict()` of community_relationship
         if self.community_relationship:
             _dict['community_relationship'] = self.community_relationship.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 content_disclosure
+        if self.content_disclosure:
+            _dict['content_disclosure'] = self.content_disclosure.to_dict()
         # override the default output from pydantic by calling `to_dict()` of core
         if self.core:
             _dict['core'] = self.core.to_dict()
@@ -147,15 +170,27 @@ class Tweet(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of edit_prespective
         if self.edit_prespective:
             _dict['edit_prespective'] = self.edit_prespective.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of grok_annotations
+        if self.grok_annotations:
+            _dict['grok_annotations'] = self.grok_annotations.to_dict()
         # override the default output from pydantic by calling `to_dict()` of grok_share_attachment
         if self.grok_share_attachment:
             _dict['grok_share_attachment'] = self.grok_share_attachment.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of grok_translated_post_with_availability
+        if self.grok_translated_post_with_availability:
+            _dict['grok_translated_post_with_availability'] = self.grok_translated_post_with_availability.to_dict()
         # override the default output from pydantic by calling `to_dict()` of legacy
         if self.legacy:
             _dict['legacy'] = self.legacy.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of nested_quoted_tweet_results
+        if self.nested_quoted_tweet_results:
+            _dict['nested_quoted_tweet_results'] = self.nested_quoted_tweet_results.to_dict()
         # override the default output from pydantic by calling `to_dict()` of note_tweet
         if self.note_tweet:
             _dict['note_tweet'] = self.note_tweet.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of post_cta
+        if self.post_cta:
+            _dict['postCta'] = self.post_cta.to_dict()
         # override the default output from pydantic by calling `to_dict()` of previous_counts
         if self.previous_counts:
             _dict['previous_counts'] = self.previous_counts.to_dict()
@@ -194,18 +229,26 @@ 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,
+            "cashtag_attachments": [CashtagAttachment.from_dict(_item) for _item in obj["cashtag_attachments"]] if obj.get("cashtag_attachments") is not None else None,
             "community_relationship": CommunityRelationship.from_dict(obj["community_relationship"]) if obj.get("community_relationship") is not None else None,
-            "community_results": Community.from_dict(obj["community_results"]) if obj.get("community_results") is not None else None,
+            "community_results": CommunityResult.from_dict(obj["community_results"]) if obj.get("community_results") is not None else None,
+            "content_disclosure": ContentDisclosure.from_dict(obj["content_disclosure"]) if obj.get("content_disclosure") 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,
             "grok_analysis_button": obj.get("grok_analysis_button"),
             "grok_analysis_followups": obj.get("grok_analysis_followups"),
+            "grok_annotations": GrokAnnotation.from_dict(obj["grok_annotations"]) if obj.get("grok_annotations") is not None else None,
             "grok_share_attachment": GrokShareAttachment.from_dict(obj["grok_share_attachment"]) if obj.get("grok_share_attachment") is not None else None,
+            "grok_translated_post_with_availability": GrokTranslatedPostWithAvailability.from_dict(obj["grok_translated_post_with_availability"]) if obj.get("grok_translated_post_with_availability") is not None else None,
             "has_birdwatch_notes": obj.get("has_birdwatch_notes"),
             "is_translatable": obj.get("is_translatable"),
             "legacy": TweetLegacy.from_dict(obj["legacy"]) if obj.get("legacy") is not None else None,
+            "nested_quoted_tweet_results": ItemResult.from_dict(obj["nested_quoted_tweet_results"]) if obj.get("nested_quoted_tweet_results") is not None else None,
             "note_tweet": NoteTweet.from_dict(obj["note_tweet"]) if obj.get("note_tweet") is not None else None,
+            "postCta": TweetPostCta.from_dict(obj["postCta"]) if obj.get("postCta") is not None else None,
+            "post_image_description": obj.get("post_image_description"),
+            "post_video_description": obj.get("post_video_description"),
             "previous_counts": TweetPreviousCounts.from_dict(obj["previous_counts"]) if obj.get("previous_counts") is not None else None,
             "quick_promote_eligibility": obj.get("quick_promote_eligibility"),
             "quotedRefResult": QuotedRefResult.from_dict(obj["quotedRefResult"]) if obj.get("quotedRefResult") is not None else None,

twitter_openapi_python_generated/models/tweet_card.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.tweet_card_legacy import TweetCardLegacy
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetCard(BaseModel):
     """
@@ -33,7 +34,8 @@ class TweetCard(BaseModel):
     __properties: ClassVar[List[str]] = ["legacy", "rest_id"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -45,8 +47,7 @@ class TweetCard(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/tweet_card_legacy.py

@@ -25,6 +25,7 @@ from twitter_openapi_python_generated.models.tweet_card_platform_data import Twe
 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 TweetCardLegacy(BaseModel):
     """
@@ -38,7 +39,8 @@ class TweetCardLegacy(BaseModel):
     __properties: ClassVar[List[str]] = ["binding_values", "card_platform", "name", "url", "user_refs_results"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -50,8 +52,7 @@ class TweetCardLegacy(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
@@ -80,8 +81,7 @@ class TweetCardLegacy(BaseModel):
         _items = []
         if self.binding_values:
             for _item_binding_values in self.binding_values:
-                if _item_binding_values:
-                    _items.append(_item_binding_values.to_dict())
+                _items.append(_item_binding_values.to_dict() if _item_binding_values is not None else None)
             _dict['binding_values'] = _items
         # override the default output from pydantic by calling `to_dict()` of card_platform
         if self.card_platform:
@@ -90,8 +90,7 @@ class TweetCardLegacy(BaseModel):
         _items = []
         if self.user_refs_results:
             for _item_user_refs_results in self.user_refs_results:
-                if _item_user_refs_results:
-                    _items.append(_item_user_refs_results.to_dict())
+                _items.append(_item_user_refs_results.to_dict() if _item_user_refs_results is not None else None)
             _dict['user_refs_results'] = _items
         return _dict
 

twitter_openapi_python_generated/models/tweet_card_legacy_binding_value.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.tweet_card_legacy_binding_value_data import TweetCardLegacyBindingValueData
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetCardLegacyBindingValue(BaseModel):
     """
@@ -33,7 +34,8 @@ class TweetCardLegacyBindingValue(BaseModel):
     __properties: ClassVar[List[str]] = ["key", "value"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -45,8 +47,7 @@ class TweetCardLegacyBindingValue(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/tweet_card_legacy_binding_value_data.py

@@ -24,6 +24,7 @@ from twitter_openapi_python_generated.models.tweet_card_legacy_binding_value_dat
 from twitter_openapi_python_generated.models.user_value import UserValue
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetCardLegacyBindingValueData(BaseModel):
     """
@@ -39,7 +40,8 @@ class TweetCardLegacyBindingValueData(BaseModel):
     __properties: ClassVar[List[str]] = ["boolean_value", "image_color_value", "image_value", "scribe_key", "string_value", "type", "user_value"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -51,8 +53,7 @@ class TweetCardLegacyBindingValueData(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/tweet_card_legacy_binding_value_data_image.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetCardLegacyBindingValueDataImage(BaseModel):
     """
@@ -34,7 +35,8 @@ class TweetCardLegacyBindingValueDataImage(BaseModel):
     __properties: ClassVar[List[str]] = ["alt", "height", "url", "width"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -46,8 +48,7 @@ class TweetCardLegacyBindingValueDataImage(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/tweet_card_platform.py

@@ -24,6 +24,7 @@ from twitter_openapi_python_generated.models.tweet_card_platform_audience import
 from twitter_openapi_python_generated.models.tweet_card_platform_device import TweetCardPlatformDevice
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetCardPlatform(BaseModel):
     """
@@ -34,7 +35,8 @@ class TweetCardPlatform(BaseModel):
     __properties: ClassVar[List[str]] = ["audience", "device"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -46,8 +48,7 @@ class TweetCardPlatform(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/tweet_card_platform_audience.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
 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 TweetCardPlatformAudience(BaseModel):
     """
@@ -38,7 +39,8 @@ class TweetCardPlatformAudience(BaseModel):
         return value
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -50,8 +52,7 @@ class TweetCardPlatformAudience(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/tweet_card_platform_data.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.tweet_card_platform import TweetCardPlatform
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetCardPlatformData(BaseModel):
     """
@@ -32,7 +33,8 @@ class TweetCardPlatformData(BaseModel):
     __properties: ClassVar[List[str]] = ["platform"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -44,8 +46,7 @@ class TweetCardPlatformData(BaseModel):
 
     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())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]: