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

twitter_openapi_python_generated/models/tweet_card_platform_device.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 TweetCardPlatformDevice(BaseModel):
     """
@@ -32,15 +33,16 @@ class TweetCardPlatformDevice(BaseModel):
     version: Annotated[str, Field(strict=True)]
     __properties: ClassVar[List[str]] = ["name", "version"]
 
-    @field_validator('version')
+    @field_validator('version', mode="before")
     def version_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=(),
     )
@@ -52,8 +54,7 @@ class TweetCardPlatformDevice(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_detail_response.py

@@ -24,6 +24,7 @@ from twitter_openapi_python_generated.models.error_response import ErrorResponse
 from twitter_openapi_python_generated.models.tweet_detail_response_data import TweetDetailResponseData
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetDetailResponse(BaseModel):
     """
@@ -34,7 +35,8 @@ class TweetDetailResponse(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 TweetDetailResponse(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]:
@@ -79,8 +80,7 @@ class TweetDetailResponse(BaseModel):
         _items = []
         if self.errors:
             for _item_errors in self.errors:
-                if _item_errors:
-                    _items.append(_item_errors.to_dict())
+                _items.append(_item_errors.to_dict() if _item_errors is not None else None)
             _dict['errors'] = _items
         return _dict
 

twitter_openapi_python_generated/models/tweet_detail_response_data.py

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

@@ -24,6 +24,7 @@ from typing_extensions import Annotated
 from twitter_openapi_python_generated.models.tweet_edit_control_initial import TweetEditControlInitial
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetEditControl(BaseModel):
     """
@@ -37,38 +38,39 @@ class TweetEditControl(BaseModel):
     is_edit_eligible: Optional[StrictBool] = None
     __properties: ClassVar[List[str]] = ["edit_control_initial", "edit_tweet_ids", "editable_until_msecs", "edits_remaining", "initial_tweet_id", "is_edit_eligible"]
 
-    @field_validator('editable_until_msecs')
+    @field_validator('editable_until_msecs', mode="before")
     def editable_until_msecs_validate_regular_expression(cls, value):
         """Validates the regular expression"""
         if value is None:
             return value
 
-        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
 
-    @field_validator('edits_remaining')
+    @field_validator('edits_remaining', mode="before")
     def edits_remaining_validate_regular_expression(cls, value):
         """Validates the regular expression"""
         if value is None:
             return value
 
-        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
 
-    @field_validator('initial_tweet_id')
+    @field_validator('initial_tweet_id', mode="before")
     def initial_tweet_id_validate_regular_expression(cls, value):
         """Validates the regular expression"""
         if value is None:
             return value
 
-        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=(),
     )
@@ -80,8 +82,7 @@ class TweetEditControl(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_edit_control_initial.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 TweetEditControlInitial(BaseModel):
     """
@@ -34,22 +35,23 @@ class TweetEditControlInitial(BaseModel):
     is_edit_eligible: StrictBool
     __properties: ClassVar[List[str]] = ["edit_tweet_ids", "editable_until_msecs", "edits_remaining", "is_edit_eligible"]
 
-    @field_validator('editable_until_msecs')
+    @field_validator('editable_until_msecs', mode="before")
     def editable_until_msecs_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
 
-    @field_validator('edits_remaining')
+    @field_validator('edits_remaining', mode="before")
     def edits_remaining_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=(),
     )
@@ -61,8 +63,7 @@ class TweetEditControlInitial(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_edit_prespective.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictBool
 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 TweetEditPrespective(BaseModel):
     """
@@ -32,7 +33,8 @@ class TweetEditPrespective(BaseModel):
     __properties: ClassVar[List[str]] = ["favorited", "retweeted"]
 
     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 TweetEditPrespective(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_favoriters_response.py

@@ -24,6 +24,7 @@ from twitter_openapi_python_generated.models.error_response import ErrorResponse
 from twitter_openapi_python_generated.models.tweet_favoriters_response_data import TweetFavoritersResponseData
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetFavoritersResponse(BaseModel):
     """
@@ -34,7 +35,8 @@ class TweetFavoritersResponse(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 TweetFavoritersResponse(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]:
@@ -79,8 +80,7 @@ class TweetFavoritersResponse(BaseModel):
         _items = []
         if self.errors:
             for _item_errors in self.errors:
-                if _item_errors:
-                    _items.append(_item_errors.to_dict())
+                _items.append(_item_errors.to_dict() if _item_errors is not None else None)
             _dict['errors'] = _items
         return _dict
 

twitter_openapi_python_generated/models/tweet_favoriters_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 TweetFavoritersResponseData(BaseModel):
     """
@@ -32,7 +33,8 @@ class TweetFavoritersResponseData(BaseModel):
     __properties: ClassVar[List[str]] = ["favoriters_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 TweetFavoritersResponseData(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_interstitial.py

@@ -25,6 +25,7 @@ from twitter_openapi_python_generated.models.tweet_interstitial_text import Twee
 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 TweetInterstitial(BaseModel):
     """
@@ -39,12 +40,13 @@ class TweetInterstitial(BaseModel):
     @field_validator('display_type')
     def display_type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in set(['NonCompliant']):
-            raise ValueError("must be one of enum values ('NonCompliant')")
+        if value not in set(['NonCompliant', 'EntireTweet']):
+            raise ValueError("must be one of enum values ('NonCompliant', 'EntireTweet')")
         return value
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -56,8 +58,7 @@ class TweetInterstitial(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_interstitial_reveal_text.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.tweet_interstitial_text_entity import TweetInterstitialTextEntity
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetInterstitialRevealText(BaseModel):
     """
@@ -34,7 +35,8 @@ class TweetInterstitialRevealText(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 TweetInterstitialRevealText(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 TweetInterstitialRevealText(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/tweet_interstitial_text.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.tweet_interstitial_text_entity import TweetInterstitialTextEntity
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetInterstitialText(BaseModel):
     """
@@ -34,7 +35,8 @@ class TweetInterstitialText(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 TweetInterstitialText(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 TweetInterstitialText(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/tweet_interstitial_text_entity.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.tweet_interstitial_text_entity_ref import TweetInterstitialTextEntityRef
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class TweetInterstitialTextEntity(BaseModel):
     """
@@ -34,7 +35,8 @@ class TweetInterstitialTextEntity(BaseModel):
     __properties: ClassVar[List[str]] = ["fromIndex", "ref", "toIndex"]
 
     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 TweetInterstitialTextEntity(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_interstitial_text_entity_ref.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 TweetInterstitialTextEntityRef(BaseModel):
     """
@@ -47,7 +48,8 @@ class TweetInterstitialTextEntityRef(BaseModel):
         return value
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -59,8 +61,7 @@ class TweetInterstitialTextEntityRef(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.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):
     """
@@ -37,9 +38,9 @@ class TweetLegacy(BaseModel):
     bookmarked: StrictBool
     conversation_control: Optional[Dict[str, Any]] = None
     conversation_id_str: Annotated[str, Field(strict=True)]
-    created_at: Annotated[str, Field(strict=True)]
+    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: Entities
+    entities: Optional[Entities] = None
     extended_entities: Optional[ExtendedEntities] = None
     favorite_count: StrictInt
     favorited: StrictBool
@@ -66,44 +67,44 @@ class TweetLegacy(BaseModel):
     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"]
 
-    @field_validator('conversation_id_str')
+    @field_validator('conversation_id_str', mode="before")
     def conversation_id_str_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
 
-    @field_validator('created_at')
+    @field_validator('created_at', mode="before")
     def created_at_validate_regular_expression(cls, value):
         """Validates the regular expression"""
-        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):
+        if isinstance(value, str) and 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
 
-    @field_validator('id_str')
+    @field_validator('id_str', mode="before")
     def id_str_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
 
-    @field_validator('in_reply_to_status_id_str')
+    @field_validator('in_reply_to_status_id_str', mode="before")
     def in_reply_to_status_id_str_validate_regular_expression(cls, value):
         """Validates the regular expression"""
         if value is None:
             return value
 
-        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
 
-    @field_validator('in_reply_to_user_id_str')
+    @field_validator('in_reply_to_user_id_str', mode="before")
     def in_reply_to_user_id_str_validate_regular_expression(cls, value):
         """Validates the regular expression"""
         if value is None:
             return value
 
-        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
 
@@ -117,25 +118,26 @@ class TweetLegacy(BaseModel):
             raise ValueError("must be one of enum values ('limited_replies', 'non_compliant', 'dynamic_product_ad', 'stale_tweet', 'community_tweet_non_member_public_community', 'community_tweet_non_member_closed_community', 'blocked_viewer')")
         return value
 
-    @field_validator('quoted_status_id_str')
+    @field_validator('quoted_status_id_str', mode="before")
     def quoted_status_id_str_validate_regular_expression(cls, value):
         """Validates the regular expression"""
         if value is None:
             return value
 
-        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
 
-    @field_validator('user_id_str')
+    @field_validator('user_id_str', mode="before")
     def user_id_str_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=(),
     )
@@ -147,8 +149,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]:
@@ -74,8 +75,7 @@ class TweetLimitedActionResults(BaseModel):
         _items = []
         if self.limited_actions:
             for _item_limited_actions in self.limited_actions:
-                if _item_limited_actions:
-                    _items.append(_item_limited_actions.to_dict())
+                _items.append(_item_limited_actions.to_dict() if _item_limited_actions is not None else None)
             _dict['limited_actions'] = _items
         return _dict