twitter-openapi-python-generated 0.0.24__py3-none-any.whl → 0.0.26__py3-none-any.whl

twitter_openapi_python_generated/models/{favorite_tweet_response_data.py → community_join_action_unavailable.py}

@@ -18,18 +18,27 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List
-from twitter_openapi_python_generated.models.favorite_tweet import FavoriteTweet
+from twitter_openapi_python_generated.models.type_name import TypeName
 from typing import Optional, Set
 from typing_extensions import Self
 
-class FavoriteTweetResponseData(BaseModel):
+class CommunityJoinActionUnavailable(BaseModel):
     """
-    FavoriteTweetResponseData
+    CommunityJoinActionUnavailable
     """ # noqa: E501
-    data: FavoriteTweet
-    __properties: ClassVar[List[str]] = ["data"]
+    typename: TypeName = Field(alias="__typename")
+    message: StrictStr
+    reason: StrictStr
+    __properties: ClassVar[List[str]] = ["__typename", "message", "reason"]
+
+    @field_validator('reason')
+    def reason_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['ViewerRequestRequired']):
+            raise ValueError("must be one of enum values ('ViewerRequestRequired')")
+        return value
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -49,7 +58,7 @@ class FavoriteTweetResponseData(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of FavoriteTweetResponseData from a JSON string"""
+        """Create an instance of CommunityJoinActionUnavailable from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -70,14 +79,11 @@ class FavoriteTweetResponseData(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of data
-        if self.data:
-            _dict['data'] = self.data.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of FavoriteTweetResponseData from a dict"""
+        """Create an instance of CommunityJoinActionUnavailable from a dict"""
         if obj is None:
             return None
 
@@ -85,7 +91,9 @@ class FavoriteTweetResponseData(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": FavoriteTweet.from_dict(obj["data"]) if obj.get("data") is not None else None
+            "__typename": obj.get("__typename"),
+            "message": obj.get("message"),
+            "reason": obj.get("reason")
         })
         return _obj
 

twitter_openapi_python_generated/models/{post_favorite_tweet200_response.py → community_join_action_union.py}

@@ -18,24 +18,24 @@ import json
 import pprint
 from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
 from typing import Any, List, Optional
-from twitter_openapi_python_generated.models.errors import Errors
-from twitter_openapi_python_generated.models.favorite_tweet_response_data import FavoriteTweetResponseData
+from twitter_openapi_python_generated.models.community_join_action_result import CommunityJoinActionResult
+from twitter_openapi_python_generated.models.community_join_action_unavailable import CommunityJoinActionUnavailable
 from pydantic import StrictStr, Field
 from typing import Union, List, Set, Optional, Dict
 from typing_extensions import Literal, Self
 
-POSTFAVORITETWEET200RESPONSE_ONE_OF_SCHEMAS = ["Errors", "FavoriteTweetResponseData"]
+COMMUNITYJOINACTIONUNION_ONE_OF_SCHEMAS = ["CommunityJoinActionResult", "CommunityJoinActionUnavailable"]
 
-class PostFavoriteTweet200Response(BaseModel):
+class CommunityJoinActionUnion(BaseModel):
     """
-    PostFavoriteTweet200Response
+    CommunityJoinActionUnion
     """
-    # data type: FavoriteTweetResponseData
-    oneof_schema_1_validator: Optional[FavoriteTweetResponseData] = None
-    # data type: Errors
-    oneof_schema_2_validator: Optional[Errors] = None
-    actual_instance: Optional[Union[Errors, FavoriteTweetResponseData]] = None
-    one_of_schemas: Set[str] = { "Errors", "FavoriteTweetResponseData" }
+    # data type: CommunityJoinActionResult
+    oneof_schema_1_validator: Optional[CommunityJoinActionResult] = None
+    # data type: CommunityJoinActionUnavailable
+    oneof_schema_2_validator: Optional[CommunityJoinActionUnavailable] = None
+    actual_instance: Optional[Union[CommunityJoinActionResult, CommunityJoinActionUnavailable]] = None
+    one_of_schemas: Set[str] = { "CommunityJoinActionResult", "CommunityJoinActionUnavailable" }
 
     model_config = ConfigDict(
         validate_assignment=True,
@@ -43,6 +43,9 @@ class PostFavoriteTweet200Response(BaseModel):
     )
 
 
+    discriminator_value_class_map: Dict[str, str] = {
+    }
+
     def __init__(self, *args, **kwargs) -> None:
         if args:
             if len(args) > 1:
@@ -55,25 +58,25 @@ class PostFavoriteTweet200Response(BaseModel):
 
     @field_validator('actual_instance')
     def actual_instance_must_validate_oneof(cls, v):
-        instance = PostFavoriteTweet200Response.model_construct()
+        instance = CommunityJoinActionUnion.model_construct()
         error_messages = []
         match = 0
-        # validate data type: FavoriteTweetResponseData
-        if not isinstance(v, FavoriteTweetResponseData):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `FavoriteTweetResponseData`")
+        # validate data type: CommunityJoinActionResult
+        if not isinstance(v, CommunityJoinActionResult):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `CommunityJoinActionResult`")
         else:
             match += 1
-        # validate data type: Errors
-        if not isinstance(v, Errors):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `Errors`")
+        # validate data type: CommunityJoinActionUnavailable
+        if not isinstance(v, CommunityJoinActionUnavailable):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `CommunityJoinActionUnavailable`")
         else:
             match += 1
         if match > 1:
             # more than 1 match
-            raise ValueError("Multiple matches found when setting `actual_instance` in PostFavoriteTweet200Response with oneOf schemas: Errors, FavoriteTweetResponseData. Details: " + ", ".join(error_messages))
+            raise ValueError("Multiple matches found when setting `actual_instance` in CommunityJoinActionUnion with oneOf schemas: CommunityJoinActionResult, CommunityJoinActionUnavailable. Details: " + ", ".join(error_messages))
         elif match == 0:
             # no match
-            raise ValueError("No match found when setting `actual_instance` in PostFavoriteTweet200Response with oneOf schemas: Errors, FavoriteTweetResponseData. Details: " + ", ".join(error_messages))
+            raise ValueError("No match found when setting `actual_instance` in CommunityJoinActionUnion with oneOf schemas: CommunityJoinActionResult, CommunityJoinActionUnavailable. Details: " + ", ".join(error_messages))
         else:
             return v
 
@@ -88,25 +91,45 @@ class PostFavoriteTweet200Response(BaseModel):
         error_messages = []
         match = 0
 
-        # deserialize data into FavoriteTweetResponseData
+        # use oneOf discriminator to lookup the data type
+        _data_type = json.loads(json_str).get("__typename")
+        if not _data_type:
+            raise ValueError("Failed to lookup data type from the field `__typename` in the input.")
+
+        # check if data type is `CommunityJoinActionResult`
+        if _data_type == "CommunityJoinAction":
+            instance.actual_instance = CommunityJoinActionResult.from_json(json_str)
+            return instance
+
+        # check if data type is `CommunityJoinActionUnavailable`
+        if _data_type == "CommunityJoinActionUnavailable":
+            instance.actual_instance = CommunityJoinActionUnavailable.from_json(json_str)
+            return instance
+
+        # check if data type is `CommunityJoinActionResult`
+        if _data_type == "CommunityJoinActionResult":
+            instance.actual_instance = CommunityJoinActionResult.from_json(json_str)
+            return instance
+
+        # deserialize data into CommunityJoinActionResult
         try:
-            instance.actual_instance = FavoriteTweetResponseData.from_json(json_str)
+            instance.actual_instance = CommunityJoinActionResult.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
-        # deserialize data into Errors
+        # deserialize data into CommunityJoinActionUnavailable
         try:
-            instance.actual_instance = Errors.from_json(json_str)
+            instance.actual_instance = CommunityJoinActionUnavailable.from_json(json_str)
             match += 1
         except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
 
         if match > 1:
             # more than 1 match
-            raise ValueError("Multiple matches found when deserializing the JSON string into PostFavoriteTweet200Response with oneOf schemas: Errors, FavoriteTweetResponseData. Details: " + ", ".join(error_messages))
+            raise ValueError("Multiple matches found when deserializing the JSON string into CommunityJoinActionUnion with oneOf schemas: CommunityJoinActionResult, CommunityJoinActionUnavailable. Details: " + ", ".join(error_messages))
         elif match == 0:
             # no match
-            raise ValueError("No match found when deserializing the JSON string into PostFavoriteTweet200Response with oneOf schemas: Errors, FavoriteTweetResponseData. Details: " + ", ".join(error_messages))
+            raise ValueError("No match found when deserializing the JSON string into CommunityJoinActionUnion with oneOf schemas: CommunityJoinActionResult, CommunityJoinActionUnavailable. Details: " + ", ".join(error_messages))
         else:
             return instance
 
@@ -120,7 +143,7 @@ class PostFavoriteTweet200Response(BaseModel):
         else:
             return json.dumps(self.actual_instance)
 
-    def to_dict(self) -> Optional[Union[Dict[str, Any], Errors, FavoriteTweetResponseData]]:
+    def to_dict(self) -> Optional[Union[Dict[str, Any], CommunityJoinActionResult, CommunityJoinActionUnavailable]]:
         """Returns the dict representation of the actual instance"""
         if self.actual_instance is None:
             return None

twitter_openapi_python_generated/models/create_bookmark_response.py

@@ -19,8 +19,9 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.create_bookmark_response_data import CreateBookmarkResponseData
+from twitter_openapi_python_generated.models.error_response import ErrorResponse
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,7 +30,8 @@ class CreateBookmarkResponse(BaseModel):
     CreateBookmarkResponse
     """ # noqa: E501
     data: CreateBookmarkResponseData
-    __properties: ClassVar[List[str]] = ["data"]
+    errors: Optional[List[ErrorResponse]] = None
+    __properties: ClassVar[List[str]] = ["data", "errors"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -73,6 +75,13 @@ class CreateBookmarkResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of data
         if self.data:
             _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+        _items = []
+        if self.errors:
+            for _item_errors in self.errors:
+                if _item_errors:
+                    _items.append(_item_errors.to_dict())
+            _dict['errors'] = _items
         return _dict
 
     @classmethod
@@ -85,7 +94,8 @@ class CreateBookmarkResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": CreateBookmarkResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None
+            "data": CreateBookmarkResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "errors": [ErrorResponse.from_dict(_item) for _item in obj["errors"]] if obj.get("errors") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/create_bookmark_response_data.py

@@ -19,7 +19,7 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, StrictStr
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,7 +27,7 @@ class CreateBookmarkResponseData(BaseModel):
     """
     CreateBookmarkResponseData
     """ # noqa: E501
-    tweet_bookmark_put: StrictStr
+    tweet_bookmark_put: Optional[StrictStr] = None
     __properties: ClassVar[List[str]] = ["tweet_bookmark_put"]
 
     model_config = ConfigDict(

twitter_openapi_python_generated/models/create_retweet_response.py

@@ -19,8 +19,9 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.create_retweet_response_data import CreateRetweetResponseData
+from twitter_openapi_python_generated.models.error_response import ErrorResponse
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,7 +30,8 @@ class CreateRetweetResponse(BaseModel):
     CreateRetweetResponse
     """ # noqa: E501
     data: CreateRetweetResponseData
-    __properties: ClassVar[List[str]] = ["data"]
+    errors: Optional[List[ErrorResponse]] = None
+    __properties: ClassVar[List[str]] = ["data", "errors"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -73,6 +75,13 @@ class CreateRetweetResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of data
         if self.data:
             _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+        _items = []
+        if self.errors:
+            for _item_errors in self.errors:
+                if _item_errors:
+                    _items.append(_item_errors.to_dict())
+            _dict['errors'] = _items
         return _dict
 
     @classmethod
@@ -85,7 +94,8 @@ class CreateRetweetResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": CreateRetweetResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None
+            "data": CreateRetweetResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "errors": [ErrorResponse.from_dict(_item) for _item in obj["errors"]] if obj.get("errors") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/create_retweet_response_data.py

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

twitter_openapi_python_generated/models/create_tweet_response.py

@@ -19,8 +19,9 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.create_tweet_response_data import CreateTweetResponseData
+from twitter_openapi_python_generated.models.error_response import ErrorResponse
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,7 +30,8 @@ class CreateTweetResponse(BaseModel):
     CreateTweetResponse
     """ # noqa: E501
     data: CreateTweetResponseData
-    __properties: ClassVar[List[str]] = ["data"]
+    errors: Optional[List[ErrorResponse]] = None
+    __properties: ClassVar[List[str]] = ["data", "errors"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -73,6 +75,13 @@ class CreateTweetResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of data
         if self.data:
             _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+        _items = []
+        if self.errors:
+            for _item_errors in self.errors:
+                if _item_errors:
+                    _items.append(_item_errors.to_dict())
+            _dict['errors'] = _items
         return _dict
 
     @classmethod
@@ -85,7 +94,8 @@ class CreateTweetResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": CreateTweetResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None
+            "data": CreateTweetResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "errors": [ErrorResponse.from_dict(_item) for _item in obj["errors"]] if obj.get("errors") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/create_tweet_response_data.py

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

twitter_openapi_python_generated/models/delete_bookmark_response.py

@@ -19,8 +19,9 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.delete_bookmark_response_data import DeleteBookmarkResponseData
+from twitter_openapi_python_generated.models.error_response import ErrorResponse
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,7 +30,8 @@ class DeleteBookmarkResponse(BaseModel):
     DeleteBookmarkResponse
     """ # noqa: E501
     data: DeleteBookmarkResponseData
-    __properties: ClassVar[List[str]] = ["data"]
+    errors: Optional[List[ErrorResponse]] = None
+    __properties: ClassVar[List[str]] = ["data", "errors"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -73,6 +75,13 @@ class DeleteBookmarkResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of data
         if self.data:
             _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+        _items = []
+        if self.errors:
+            for _item_errors in self.errors:
+                if _item_errors:
+                    _items.append(_item_errors.to_dict())
+            _dict['errors'] = _items
         return _dict
 
     @classmethod
@@ -85,7 +94,8 @@ class DeleteBookmarkResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": DeleteBookmarkResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None
+            "data": DeleteBookmarkResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "errors": [ErrorResponse.from_dict(_item) for _item in obj["errors"]] if obj.get("errors") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/delete_bookmark_response_data.py

@@ -19,7 +19,7 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, StrictStr
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,7 +27,7 @@ class DeleteBookmarkResponseData(BaseModel):
     """
     DeleteBookmarkResponseData
     """ # noqa: E501
-    tweet_bookmark_delete: StrictStr
+    tweet_bookmark_delete: Optional[StrictStr] = None
     __properties: ClassVar[List[str]] = ["tweet_bookmark_delete"]
 
     model_config = ConfigDict(

twitter_openapi_python_generated/models/delete_retweet_response.py

@@ -19,8 +19,9 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.delete_retweet_response_data import DeleteRetweetResponseData
+from twitter_openapi_python_generated.models.error_response import ErrorResponse
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,7 +30,8 @@ class DeleteRetweetResponse(BaseModel):
     DeleteRetweetResponse
     """ # noqa: E501
     data: DeleteRetweetResponseData
-    __properties: ClassVar[List[str]] = ["data"]
+    errors: Optional[List[ErrorResponse]] = None
+    __properties: ClassVar[List[str]] = ["data", "errors"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -73,6 +75,13 @@ class DeleteRetweetResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of data
         if self.data:
             _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+        _items = []
+        if self.errors:
+            for _item_errors in self.errors:
+                if _item_errors:
+                    _items.append(_item_errors.to_dict())
+            _dict['errors'] = _items
         return _dict
 
     @classmethod
@@ -85,7 +94,8 @@ class DeleteRetweetResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": DeleteRetweetResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None
+            "data": DeleteRetweetResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "errors": [ErrorResponse.from_dict(_item) for _item in obj["errors"]] if obj.get("errors") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/delete_retweet_response_data.py

@@ -20,7 +20,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict
 from typing import Any, ClassVar, Dict, List, Optional
-from twitter_openapi_python_generated.models.create_retweet_response_result import CreateRetweetResponseResult
+from twitter_openapi_python_generated.models.delete_retweet_response_result import DeleteRetweetResponseResult
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -28,7 +28,7 @@ class DeleteRetweetResponseData(BaseModel):
     """
     DeleteRetweetResponseData
     """ # noqa: E501
-    create_retweet: Optional[CreateRetweetResponseResult] = None
+    create_retweet: Optional[DeleteRetweetResponseResult] = None
     __properties: ClassVar[List[str]] = ["create_retweet"]
 
     model_config = ConfigDict(
@@ -85,7 +85,7 @@ class DeleteRetweetResponseData(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "create_retweet": CreateRetweetResponseResult.from_dict(obj["create_retweet"]) if obj.get("create_retweet") is not None else None
+            "create_retweet": DeleteRetweetResponseResult.from_dict(obj["create_retweet"]) if obj.get("create_retweet") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/delete_tweet_response.py

@@ -19,8 +19,9 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.delete_tweet_response_data import DeleteTweetResponseData
+from twitter_openapi_python_generated.models.error_response import ErrorResponse
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,7 +30,8 @@ class DeleteTweetResponse(BaseModel):
     DeleteTweetResponse
     """ # noqa: E501
     data: DeleteTweetResponseData
-    __properties: ClassVar[List[str]] = ["data"]
+    errors: Optional[List[ErrorResponse]] = None
+    __properties: ClassVar[List[str]] = ["data", "errors"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -73,6 +75,13 @@ class DeleteTweetResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of data
         if self.data:
             _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+        _items = []
+        if self.errors:
+            for _item_errors in self.errors:
+                if _item_errors:
+                    _items.append(_item_errors.to_dict())
+            _dict['errors'] = _items
         return _dict
 
     @classmethod
@@ -85,7 +94,8 @@ class DeleteTweetResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": DeleteTweetResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None
+            "data": DeleteTweetResponseData.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "errors": [ErrorResponse.from_dict(_item) for _item in obj["errors"]] if obj.get("errors") is not None else None
         })
         return _obj
 

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

@@ -26,9 +26,9 @@ from twitter_openapi_python_generated.models.tracing import Tracing
 from typing import Optional, Set
 from typing_extensions import Self
 
-class Error(BaseModel):
+class ErrorResponse(BaseModel):
     """
-    Error
+    ErrorResponse
     """ # noqa: E501
     code: StrictInt
     extensions: ErrorExtensions
@@ -36,7 +36,7 @@ class Error(BaseModel):
     locations: List[Location]
     message: StrictStr
     name: StrictStr
-    path: List[StrictStr]
+    path: List[Any]
     retry_after: Optional[StrictInt] = None
     source: StrictStr
     tracing: Tracing
@@ -60,7 +60,7 @@ class Error(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of Error from a JSON string"""
+        """Create an instance of ErrorResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -98,7 +98,7 @@ class Error(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of Error from a dict"""
+        """Create an instance of ErrorResponse from a dict"""
         if obj is None:
             return None
 

twitter_openapi_python_generated/models/favorite_tweet.py

@@ -19,7 +19,7 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, StrictStr
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,7 +27,7 @@ class FavoriteTweet(BaseModel):
     """
     FavoriteTweet
     """ # noqa: E501
-    favorite_tweet: StrictStr
+    favorite_tweet: Optional[StrictStr] = None
     __properties: ClassVar[List[str]] = ["favorite_tweet"]
 
     model_config = ConfigDict(