twitter-openapi-python-generated 0.0.32__py3-none-any.whl → 0.0.34__py3-none-any.whl

twitter_openapi_python_generated/models/tweet_legacy.py

@@ -28,6 +28,7 @@ from twitter_openapi_python_generated.models.self_thread import SelfThread
 from twitter_openapi_python_generated.models.tweet_legacy_scopes import TweetLegacyScopes
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetLegacy(BaseModel):
     """
@@ -39,7 +40,7 @@ class TweetLegacy(BaseModel):
     conversation_id_str: Annotated[str, Field(strict=True)]
     created_at: Annotated[str, Field(strict=True)]
     display_text_range: List[StrictInt]
-    entities: Entities
+    entities: Optional[Entities] = None
     extended_entities: Optional[ExtendedEntities] = None
     favorite_count: StrictInt
     favorited: StrictBool
@@ -69,6 +70,9 @@ class TweetLegacy(BaseModel):
     @field_validator('conversation_id_str')
     def conversation_id_str_validate_regular_expression(cls, value):
         """Validates the regular expression"""
+        if not isinstance(value, str):
+            value = str(value)
+
         if not re.match(r"^[0-9]+$", value):
             raise ValueError(r"must validate the regular expression /^[0-9]+$/")
         return value
@@ -76,6 +80,9 @@ class TweetLegacy(BaseModel):
     @field_validator('created_at')
     def created_at_validate_regular_expression(cls, value):
         """Validates the regular expression"""
+        if not isinstance(value, str):
+            value = str(value)
+
         if not re.match(r"^(Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (0[1-9]|[12][0-9]|3[01]) (0[0-9]|1[0-9]|2[0-3])(: ?)([0-5][0-9])(: ?)([0-5][0-9]) ([+-][0-9]{4}) ([0-9]{4})$", value):
             raise ValueError(r"must validate the regular expression /^(Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (0[1-9]|[12][0-9]|3[01]) (0[0-9]|1[0-9]|2[0-3])(: ?)([0-5][0-9])(: ?)([0-5][0-9]) ([+-][0-9]{4}) ([0-9]{4})$/")
         return value
@@ -83,6 +90,9 @@ class TweetLegacy(BaseModel):
     @field_validator('id_str')
     def id_str_validate_regular_expression(cls, value):
         """Validates the regular expression"""
+        if not isinstance(value, str):
+            value = str(value)
+
         if not re.match(r"^[0-9]+$", value):
             raise ValueError(r"must validate the regular expression /^[0-9]+$/")
         return value
@@ -93,6 +103,9 @@ class TweetLegacy(BaseModel):
         if value is None:
             return value
 
+        if not isinstance(value, str):
+            value = str(value)
+
         if not re.match(r"^[0-9]+$", value):
             raise ValueError(r"must validate the regular expression /^[0-9]+$/")
         return value
@@ -103,6 +116,9 @@ class TweetLegacy(BaseModel):
         if value is None:
             return value
 
+        if not isinstance(value, str):
+            value = str(value)
+
         if not re.match(r"^[0-9]+$", value):
             raise ValueError(r"must validate the regular expression /^[0-9]+$/")
         return value
@@ -123,6 +139,9 @@ class TweetLegacy(BaseModel):
         if value is None:
             return value
 
+        if not isinstance(value, str):
+            value = str(value)
+
         if not re.match(r"^[0-9]+$", value):
             raise ValueError(r"must validate the regular expression /^[0-9]+$/")
         return value
@@ -130,12 +149,16 @@ class TweetLegacy(BaseModel):
     @field_validator('user_id_str')
     def user_id_str_validate_regular_expression(cls, value):
         """Validates the regular expression"""
+        if not isinstance(value, str):
+            value = str(value)
+
         if 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=(),
     )
@@ -147,8 +170,7 @@ class TweetLegacy(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_legacy_scopes.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictBool
 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 TweetLegacyScopes(BaseModel):
     """
@@ -31,7 +32,8 @@ class TweetLegacyScopes(BaseModel):
     __properties: ClassVar[List[str]] = ["followers"]
 
     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 TweetLegacyScopes(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_limited_action_results.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.limited_action_results_data import LimitedActionResultsData
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetLimitedActionResults(BaseModel):
     """
@@ -32,7 +33,8 @@ class TweetLimitedActionResults(BaseModel):
     __properties: ClassVar[List[str]] = ["limited_actions"]
 
     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 TweetLimitedActionResults(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_post_cta.py

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

twitter_openapi_python_generated/models/tweet_preview_display.py

@@ -26,6 +26,7 @@ from twitter_openapi_python_generated.models.tweet_preview_display_tweet import
 from twitter_openapi_python_generated.models.type_name import TypeName
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetPreviewDisplay(BaseModel):
     """
@@ -38,7 +39,8 @@ class TweetPreviewDisplay(BaseModel):
     __properties: ClassVar[List[str]] = ["__typename", "cta", "limited_action_results", "tweet"]
 
     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 TweetPreviewDisplay(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_preview_display_cta.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.tweet_preview_display_cta_url import TweetPreviewDisplayCtaUrl
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetPreviewDisplayCta(BaseModel):
     """
@@ -33,7 +34,8 @@ class TweetPreviewDisplayCta(BaseModel):
     __properties: ClassVar[List[str]] = ["title", "url"]
 
     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 TweetPreviewDisplayCta(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_preview_display_cta_url.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, Field, 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 TweetPreviewDisplayCtaUrl(BaseModel):
     """
@@ -39,7 +40,8 @@ class TweetPreviewDisplayCtaUrl(BaseModel):
         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 TweetPreviewDisplayCtaUrl(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_preview_display_tweet.py

@@ -19,17 +19,20 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from typing_extensions import Annotated
+from twitter_openapi_python_generated.models.article_preview import ArticlePreview
 from twitter_openapi_python_generated.models.tweet_preview_display_tweet_view_count import TweetPreviewDisplayTweetViewCount
 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 TweetPreviewDisplayTweet(BaseModel):
     """
     TweetPreviewDisplayTweet
     """ # noqa: E501
+    article_preview: Optional[ArticlePreview] = None
     bookmark_count: StrictInt
     core: UserResultCore
     created_at: Annotated[str, Field(strict=True)]
@@ -41,11 +44,14 @@ class TweetPreviewDisplayTweet(BaseModel):
     retweet_count: StrictInt
     text: StrictStr
     view_count: TweetPreviewDisplayTweetViewCount
-    __properties: ClassVar[List[str]] = ["bookmark_count", "core", "created_at", "entities", "favorite_count", "quote_count", "reply_count", "rest_id", "retweet_count", "text", "view_count"]
+    __properties: ClassVar[List[str]] = ["article_preview", "bookmark_count", "core", "created_at", "entities", "favorite_count", "quote_count", "reply_count", "rest_id", "retweet_count", "text", "view_count"]
 
     @field_validator('created_at')
     def created_at_validate_regular_expression(cls, value):
         """Validates the regular expression"""
+        if not isinstance(value, str):
+            value = str(value)
+
         if not re.match(r"^(Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (0[1-9]|[12][0-9]|3[01]) (0[0-9]|1[0-9]|2[0-3])(: ?)([0-5][0-9])(: ?)([0-5][0-9]) ([+-][0-9]{4}) ([0-9]{4})$", value):
             raise ValueError(r"must validate the regular expression /^(Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (0[1-9]|[12][0-9]|3[01]) (0[0-9]|1[0-9]|2[0-3])(: ?)([0-5][0-9])(: ?)([0-5][0-9]) ([+-][0-9]{4}) ([0-9]{4})$/")
         return value
@@ -53,12 +59,16 @@ class TweetPreviewDisplayTweet(BaseModel):
     @field_validator('rest_id')
     def rest_id_validate_regular_expression(cls, value):
         """Validates the regular expression"""
+        if not isinstance(value, str):
+            value = str(value)
+
         if 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=(),
     )
@@ -70,8 +80,7 @@ class TweetPreviewDisplayTweet(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]:
@@ -96,6 +105,9 @@ class TweetPreviewDisplayTweet(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of article_preview
+        if self.article_preview:
+            _dict['article_preview'] = self.article_preview.to_dict()
         # override the default output from pydantic by calling `to_dict()` of core
         if self.core:
             _dict['core'] = self.core.to_dict()
@@ -114,6 +126,7 @@ class TweetPreviewDisplayTweet(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "article_preview": ArticlePreview.from_dict(obj["article_preview"]) if obj.get("article_preview") is not None else None,
             "bookmark_count": obj.get("bookmark_count"),
             "core": UserResultCore.from_dict(obj["core"]) if obj.get("core") is not None else None,
             "created_at": obj.get("created_at"),

twitter_openapi_python_generated/models/tweet_preview_display_tweet_view_count.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 TweetPreviewDisplayTweetViewCount(BaseModel):
     """
@@ -34,12 +35,16 @@ class TweetPreviewDisplayTweetViewCount(BaseModel):
     @field_validator('count')
     def count_validate_regular_expression(cls, value):
         """Validates the regular expression"""
+        if not isinstance(value, str):
+            value = str(value)
+
         if 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 +56,7 @@ class TweetPreviewDisplayTweetViewCount(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_previous_counts.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictInt
 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 TweetPreviousCounts(BaseModel):
     """
@@ -35,7 +36,8 @@ class TweetPreviousCounts(BaseModel):
     __properties: ClassVar[List[str]] = ["bookmark_count", "favorite_count", "quote_count", "reply_count", "retweet_count"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -47,8 +49,7 @@ class TweetPreviousCounts(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_result_by_rest_id_data.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.item_result import ItemResult
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetResultByRestIdData(BaseModel):
     """
@@ -32,7 +33,8 @@ class TweetResultByRestIdData(BaseModel):
     __properties: ClassVar[List[str]] = ["tweetResult"]
 
     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 TweetResultByRestIdData(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_result_by_rest_id_response.py

@@ -24,6 +24,7 @@ from twitter_openapi_python_generated.models.error_response import ErrorResponse
 from twitter_openapi_python_generated.models.tweet_result_by_rest_id_data import TweetResultByRestIdData
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetResultByRestIdResponse(BaseModel):
     """
@@ -34,7 +35,8 @@ class TweetResultByRestIdResponse(BaseModel):
     __properties: ClassVar[List[str]] = ["data", "errors"]
 
     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 TweetResultByRestIdResponse(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_retweeters_response.py

@@ -24,6 +24,7 @@ from twitter_openapi_python_generated.models.error_response import ErrorResponse
 from twitter_openapi_python_generated.models.tweet_retweeters_response_data import TweetRetweetersResponseData
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetRetweetersResponse(BaseModel):
     """
@@ -34,7 +35,8 @@ class TweetRetweetersResponse(BaseModel):
     __properties: ClassVar[List[str]] = ["data", "errors"]
 
     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 TweetRetweetersResponse(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_retweeters_response_data.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.timeline_result import TimelineResult
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetRetweetersResponseData(BaseModel):
     """
@@ -32,7 +33,8 @@ class TweetRetweetersResponseData(BaseModel):
     __properties: ClassVar[List[str]] = ["retweeters_timeline"]
 
     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 TweetRetweetersResponseData(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_tombstone.py

@@ -23,6 +23,7 @@ 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
+from pydantic_core import to_jsonable_python
 
 class TweetTombstone(BaseModel):
     """
@@ -33,7 +34,8 @@ class TweetTombstone(BaseModel):
     __properties: ClassVar[List[str]] = ["__typename"]
 
     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 TweetTombstone(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_unavailable.py

@@ -23,6 +23,7 @@ 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
+from pydantic_core import to_jsonable_python
 
 class TweetUnavailable(BaseModel):
     """
@@ -33,7 +34,8 @@ class TweetUnavailable(BaseModel):
     __properties: ClassVar[List[str]] = ["__typename", "reason"]
 
     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 TweetUnavailable(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]: