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

twitter_openapi_python_generated/models/note_tweet.py

@@ -19,21 +19,23 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, StrictBool
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.note_tweet_result import NoteTweetResult
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class NoteTweet(BaseModel):
     """
     NoteTweet
     """ # noqa: E501
-    is_expandable: StrictBool
+    is_expandable: Optional[StrictBool] = None
     note_tweet_results: NoteTweetResult
     __properties: ClassVar[List[str]] = ["is_expandable", "note_tweet_results"]
 
     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 NoteTweet(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/note_tweet_result.py

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

@@ -26,6 +26,7 @@ from twitter_openapi_python_generated.models.note_tweet_result_media import Note
 from twitter_openapi_python_generated.models.note_tweet_result_rich_text import NoteTweetResultRichText
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class NoteTweetResultData(BaseModel):
     """
@@ -41,12 +42,16 @@ class NoteTweetResultData(BaseModel):
     @field_validator('id')
     def id_validate_regular_expression(cls, value):
         """Validates the regular expression"""
+        if not isinstance(value, str):
+            value = str(value)
+
         if not re.match(r"^([A-Za-z0-9+\/]{4})*([A-Za-z0-9+\/]{3}=|[A-Za-z0-9+\/]{2}==)?$", value):
             raise ValueError(r"must validate the regular expression /^([A-Za-z0-9+\/]{4})*([A-Za-z0-9+\/]{3}=|[A-Za-z0-9+\/]{2}==)?$/")
         return value
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -58,8 +63,7 @@ class NoteTweetResultData(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/note_tweet_result_media.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.note_tweet_result_media_inline_media import NoteTweetResultMediaInlineMedia
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class NoteTweetResultMedia(BaseModel):
     """
@@ -32,7 +33,8 @@ class NoteTweetResultMedia(BaseModel):
     __properties: ClassVar[List[str]] = ["inline_media"]
 
     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 NoteTweetResultMedia(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/note_tweet_result_media_inline_media.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 NoteTweetResultMediaInlineMedia(BaseModel):
     """
@@ -35,12 +36,16 @@ class NoteTweetResultMediaInlineMedia(BaseModel):
     @field_validator('media_id')
     def media_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=(),
     )
@@ -52,8 +57,7 @@ class NoteTweetResultMediaInlineMedia(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/note_tweet_result_rich_text.py

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

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr, field_validato
 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 NoteTweetResultRichTextTag(BaseModel):
     """
@@ -41,7 +42,8 @@ class NoteTweetResultRichTextTag(BaseModel):
         return value
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -53,8 +55,7 @@ class NoteTweetResultRichTextTag(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/notification_template.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 NotificationTemplate(BaseModel):
     """
@@ -34,7 +35,8 @@ class NotificationTemplate(BaseModel):
     __properties: ClassVar[List[str]] = ["__typename", "from_users", "target_objects"]
 
     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 NotificationTemplate(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/notifications_result.py

@@ -25,6 +25,7 @@ from twitter_openapi_python_generated.models.timeline_result import TimelineResu
 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 NotificationsResult(BaseModel):
     """
@@ -38,12 +39,16 @@ class NotificationsResult(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=(),
     )
@@ -55,8 +60,7 @@ class NotificationsResult(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/notifications_timeline_data.py

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

@@ -24,6 +24,7 @@ from twitter_openapi_python_generated.models.error_response import ErrorResponse
 from twitter_openapi_python_generated.models.notifications_timeline_data import NotificationsTimelineData
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class NotificationsTimelineResponse(BaseModel):
     """
@@ -34,7 +35,8 @@ class NotificationsTimelineResponse(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 NotificationsTimelineResponse(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/notifications_user_results.py

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

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

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, Field, StrictStr
 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 OneFactorLoginEligibility(BaseModel):
     """
@@ -31,7 +32,8 @@ class OneFactorLoginEligibility(BaseModel):
     __properties: ClassVar[List[str]] = ["fetchStatus"]
 
     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 OneFactorLoginEligibility(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/other_object_all.py

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

@@ -23,19 +23,19 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.post_create_bookmark_request_variables import PostCreateBookmarkRequestVariables
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class PostCreateBookmarkRequest(BaseModel):
     """
     PostCreateBookmarkRequest
     """ # noqa: E501
-    method: StrictStr = Field(alias="@method")
-    path: StrictStr = Field(alias="@path")
     query_id: StrictStr = Field(alias="queryId")
     variables: PostCreateBookmarkRequestVariables
-    __properties: ClassVar[List[str]] = ["@method", "@path", "queryId", "variables"]
+    __properties: ClassVar[List[str]] = ["queryId", "variables"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -47,8 +47,7 @@ class PostCreateBookmarkRequest(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]:
@@ -88,8 +87,6 @@ class PostCreateBookmarkRequest(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "@method": obj.get("@method") if obj.get("@method") is not None else 'POST',
-            "@path": obj.get("@path") if obj.get("@path") is not None else '/i/api/graphql/aoDbu3RHznuiSkQ9aNM67Q/CreateBookmark',
             "queryId": obj.get("queryId") if obj.get("queryId") is not None else 'aoDbu3RHznuiSkQ9aNM67Q',
             "variables": PostCreateBookmarkRequestVariables.from_dict(obj["variables"]) if obj.get("variables") is not None else None
         })

twitter_openapi_python_generated/models/post_create_bookmark_request_variables.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictStr
 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 PostCreateBookmarkRequestVariables(BaseModel):
     """
@@ -31,7 +32,8 @@ class PostCreateBookmarkRequestVariables(BaseModel):
     __properties: ClassVar[List[str]] = ["tweet_id"]
 
     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 PostCreateBookmarkRequestVariables(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/post_create_retweet_request.py

@@ -23,19 +23,19 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.post_create_retweet_request_variables import PostCreateRetweetRequestVariables
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class PostCreateRetweetRequest(BaseModel):
     """
     PostCreateRetweetRequest
     """ # noqa: E501
-    method: StrictStr = Field(alias="@method")
-    path: StrictStr = Field(alias="@path")
     query_id: StrictStr = Field(alias="queryId")
     variables: PostCreateRetweetRequestVariables
-    __properties: ClassVar[List[str]] = ["@method", "@path", "queryId", "variables"]
+    __properties: ClassVar[List[str]] = ["queryId", "variables"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -47,8 +47,7 @@ class PostCreateRetweetRequest(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]:
@@ -88,9 +87,7 @@ class PostCreateRetweetRequest(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "@method": obj.get("@method") if obj.get("@method") is not None else 'POST',
-            "@path": obj.get("@path") if obj.get("@path") is not None else '/i/api/graphql/ojPdsZsimiJrUGLR1sjUtA/CreateRetweet',
-            "queryId": obj.get("queryId") if obj.get("queryId") is not None else 'ojPdsZsimiJrUGLR1sjUtA',
+            "queryId": obj.get("queryId") if obj.get("queryId") is not None else 'mbRO74GrOvSfRcJnlMapnQ',
             "variables": PostCreateRetweetRequestVariables.from_dict(obj["variables"]) if obj.get("variables") is not None else None
         })
         return _obj

twitter_openapi_python_generated/models/post_create_retweet_request_variables.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
 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 PostCreateRetweetRequestVariables(BaseModel):
     """
@@ -32,7 +33,8 @@ class PostCreateRetweetRequestVariables(BaseModel):
     __properties: ClassVar[List[str]] = ["dark_request", "tweet_id"]
 
     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 PostCreateRetweetRequestVariables(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/post_create_tweet_request.py

@@ -24,20 +24,20 @@ from twitter_openapi_python_generated.models.post_create_tweet_request_features
 from twitter_openapi_python_generated.models.post_create_tweet_request_variables import PostCreateTweetRequestVariables
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class PostCreateTweetRequest(BaseModel):
     """
     PostCreateTweetRequest
     """ # noqa: E501
-    method: StrictStr = Field(alias="@method")
-    path: StrictStr = Field(alias="@path")
     features: PostCreateTweetRequestFeatures
     query_id: StrictStr = Field(alias="queryId")
     variables: PostCreateTweetRequestVariables
-    __properties: ClassVar[List[str]] = ["@method", "@path", "features", "queryId", "variables"]
+    __properties: ClassVar[List[str]] = ["features", "queryId", "variables"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -49,8 +49,7 @@ class PostCreateTweetRequest(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]:
@@ -93,10 +92,8 @@ class PostCreateTweetRequest(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "@method": obj.get("@method") if obj.get("@method") is not None else 'POST',
-            "@path": obj.get("@path") if obj.get("@path") is not None else '/i/api/graphql/IID9x6WsdMnTlXnzXGq8ng/CreateTweet',
             "features": PostCreateTweetRequestFeatures.from_dict(obj["features"]) if obj.get("features") is not None else None,
-            "queryId": obj.get("queryId") if obj.get("queryId") is not None else 'IID9x6WsdMnTlXnzXGq8ng',
+            "queryId": obj.get("queryId") if obj.get("queryId") is not None else '5CdvsV_zjv4L64XFifAglw',
             "variables": PostCreateTweetRequestVariables.from_dict(obj["variables"]) if obj.get("variables") is not None else None
         })
         return _obj