twitter-openapi-python-generated 0.0.15__py3-none-any.whl → 0.0.16__py3-none-any.whl

twitter_openapi_python_generated/models/social_context_union.py

@@ -21,7 +21,7 @@ from typing import Any, List, Optional
 from twitter_openapi_python_generated.models.timeline_general_context import TimelineGeneralContext
 from twitter_openapi_python_generated.models.timeline_topic_context import TimelineTopicContext
 from pydantic import StrictStr, Field
-from typing import Union, List, Optional, Dict
+from typing import Union, List, Set, Optional, Dict
 from typing_extensions import Literal, Self
 
 SOCIALCONTEXTUNION_ONE_OF_SCHEMAS = ["TimelineGeneralContext", "TimelineTopicContext"]
@@ -35,7 +35,7 @@ class SocialContextUnion(BaseModel):
     # data type: TimelineTopicContext
     oneof_schema_2_validator: Optional[TimelineTopicContext] = None
     actual_instance: Optional[Union[TimelineGeneralContext, TimelineTopicContext]] = None
-    one_of_schemas: List[str] = Field(default=Literal["TimelineGeneralContext", "TimelineTopicContext"])
+    one_of_schemas: Set[str] = { "TimelineGeneralContext", "TimelineTopicContext" }
 
     model_config = ConfigDict(
         validate_assignment=True,

twitter_openapi_python_generated/models/tweet_union.py

@@ -20,7 +20,7 @@ from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, f
 from typing import Any, List, Optional
 from twitter_openapi_python_generated.models.tweet_tombstone import TweetTombstone
 from pydantic import StrictStr, Field
-from typing import Union, List, Optional, Dict
+from typing import Union, List, Set, Optional, Dict
 from typing_extensions import Literal, Self
 
 TWEETUNION_ONE_OF_SCHEMAS = ["Tweet", "TweetTombstone", "TweetWithVisibilityResults"]
@@ -36,7 +36,7 @@ class TweetUnion(BaseModel):
     # data type: TweetTombstone
     oneof_schema_3_validator: Optional[TweetTombstone] = None
     actual_instance: Optional[Union[Tweet, TweetTombstone, TweetWithVisibilityResults]] = None
-    one_of_schemas: List[str] = Field(default=Literal["Tweet", "TweetTombstone", "TweetWithVisibilityResults"])
+    one_of_schemas: Set[str] = { "Tweet", "TweetTombstone", "TweetWithVisibilityResults" }
 
     model_config = ConfigDict(
         validate_assignment=True,

twitter_openapi_python_generated/models/tweet_with_visibility_results.py

@@ -20,6 +20,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field
 from typing import Any, ClassVar, Dict, List, Optional
+from twitter_openapi_python_generated.models.media_visibility_results import MediaVisibilityResults
 from twitter_openapi_python_generated.models.tweet_interstitial import TweetInterstitial
 from twitter_openapi_python_generated.models.type_name import TypeName
 from typing import Optional, Set
@@ -31,9 +32,10 @@ class TweetWithVisibilityResults(BaseModel):
     """ # noqa: E501
     typename: TypeName = Field(alias="__typename")
     limited_action_results: Optional[Dict[str, Any]] = Field(default=None, alias="limitedActionResults")
+    media_visibility_results: Optional[MediaVisibilityResults] = Field(default=None, alias="mediaVisibilityResults")
     tweet: Tweet
     tweet_interstitial: Optional[TweetInterstitial] = Field(default=None, alias="tweetInterstitial")
-    __properties: ClassVar[List[str]] = ["__typename", "limitedActionResults", "tweet", "tweetInterstitial"]
+    __properties: ClassVar[List[str]] = ["__typename", "limitedActionResults", "mediaVisibilityResults", "tweet", "tweetInterstitial"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -74,6 +76,9 @@ class TweetWithVisibilityResults(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of media_visibility_results
+        if self.media_visibility_results:
+            _dict['mediaVisibilityResults'] = self.media_visibility_results.to_dict()
         # override the default output from pydantic by calling `to_dict()` of tweet
         if self.tweet:
             _dict['tweet'] = self.tweet.to_dict()
@@ -94,6 +99,7 @@ class TweetWithVisibilityResults(BaseModel):
         _obj = cls.model_validate({
             "__typename": obj.get("__typename"),
             "limitedActionResults": obj.get("limitedActionResults"),
+            "mediaVisibilityResults": MediaVisibilityResults.from_dict(obj["mediaVisibilityResults"]) if obj.get("mediaVisibilityResults") is not None else None,
             "tweet": Tweet.from_dict(obj["tweet"]) if obj.get("tweet") is not None else None,
             "tweetInterstitial": TweetInterstitial.from_dict(obj["tweetInterstitial"]) if obj.get("tweetInterstitial") is not None else None
         })

twitter_openapi_python_generated/models/url.py

@@ -19,7 +19,7 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, StrictInt, 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
 
@@ -28,7 +28,7 @@ class Url(BaseModel):
     Url
     """ # noqa: E501
     display_url: StrictStr
-    expanded_url: StrictStr
+    expanded_url: Optional[StrictStr] = None
     indices: List[StrictInt]
     url: StrictStr
     __properties: ClassVar[List[str]] = ["display_url", "expanded_url", "indices", "url"]

twitter_openapi_python_generated/models/user.py

@@ -24,7 +24,9 @@ from typing_extensions import Annotated
 from twitter_openapi_python_generated.models.type_name import TypeName
 from twitter_openapi_python_generated.models.user_highlights_info import UserHighlightsInfo
 from twitter_openapi_python_generated.models.user_legacy import UserLegacy
+from twitter_openapi_python_generated.models.user_legacy_extended_profile import UserLegacyExtendedProfile
 from twitter_openapi_python_generated.models.user_professional import UserProfessional
+from twitter_openapi_python_generated.models.user_tip_jar_settings import UserTipJarSettings
 from twitter_openapi_python_generated.models.user_verification_info import UserVerificationInfo
 from typing import Optional, Set
 from typing_extensions import Self
@@ -44,15 +46,17 @@ class User(BaseModel):
     is_blue_verified: StrictBool
     is_profile_translatable: Optional[StrictBool] = None
     legacy: UserLegacy
+    legacy_extended_profile: Optional[UserLegacyExtendedProfile] = None
     professional: Optional[UserProfessional] = None
     profile_image_shape: StrictStr
     rest_id: Annotated[str, Field(strict=True)]
     super_follow_eligible: StrictBool
     super_followed_by: StrictBool
     super_following: StrictBool
+    tipjar_settings: Optional[UserTipJarSettings] = None
     user_seed_tweet_count: Optional[StrictInt] = None
     verification_info: Optional[UserVerificationInfo] = None
-    __properties: ClassVar[List[str]] = ["__typename", "affiliates_highlighted_label", "business_account", "creator_subscriptions_count", "has_graduated_access", "has_nft_avatar", "highlights_info", "id", "is_blue_verified", "is_profile_translatable", "legacy", "professional", "profile_image_shape", "rest_id", "super_follow_eligible", "super_followed_by", "super_following", "user_seed_tweet_count", "verification_info"]
+    __properties: ClassVar[List[str]] = ["__typename", "affiliates_highlighted_label", "business_account", "creator_subscriptions_count", "has_graduated_access", "has_nft_avatar", "highlights_info", "id", "is_blue_verified", "is_profile_translatable", "legacy", "legacy_extended_profile", "professional", "profile_image_shape", "rest_id", "super_follow_eligible", "super_followed_by", "super_following", "tipjar_settings", "user_seed_tweet_count", "verification_info"]
 
     @field_validator('id')
     def id_validate_regular_expression(cls, value):
@@ -120,9 +124,15 @@ class User(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of legacy
         if self.legacy:
             _dict['legacy'] = self.legacy.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of legacy_extended_profile
+        if self.legacy_extended_profile:
+            _dict['legacy_extended_profile'] = self.legacy_extended_profile.to_dict()
         # override the default output from pydantic by calling `to_dict()` of professional
         if self.professional:
             _dict['professional'] = self.professional.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of tipjar_settings
+        if self.tipjar_settings:
+            _dict['tipjar_settings'] = self.tipjar_settings.to_dict()
         # override the default output from pydantic by calling `to_dict()` of verification_info
         if self.verification_info:
             _dict['verification_info'] = self.verification_info.to_dict()
@@ -149,12 +159,14 @@ class User(BaseModel):
             "is_blue_verified": obj.get("is_blue_verified") if obj.get("is_blue_verified") is not None else False,
             "is_profile_translatable": obj.get("is_profile_translatable"),
             "legacy": UserLegacy.from_dict(obj["legacy"]) if obj.get("legacy") is not None else None,
+            "legacy_extended_profile": UserLegacyExtendedProfile.from_dict(obj["legacy_extended_profile"]) if obj.get("legacy_extended_profile") is not None else None,
             "professional": UserProfessional.from_dict(obj["professional"]) if obj.get("professional") is not None else None,
             "profile_image_shape": obj.get("profile_image_shape"),
             "rest_id": obj.get("rest_id"),
             "super_follow_eligible": obj.get("super_follow_eligible") if obj.get("super_follow_eligible") is not None else False,
             "super_followed_by": obj.get("super_followed_by") if obj.get("super_followed_by") is not None else False,
             "super_following": obj.get("super_following") if obj.get("super_following") is not None else False,
+            "tipjar_settings": UserTipJarSettings.from_dict(obj["tipjar_settings"]) if obj.get("tipjar_settings") is not None else None,
             "user_seed_tweet_count": obj.get("user_seed_tweet_count"),
             "verification_info": UserVerificationInfo.from_dict(obj["verification_info"]) if obj.get("verification_info") is not None else None
         })

twitter_openapi_python_generated/models/user_legacy_extended_profile.py

@@ -0,0 +1,92 @@
+# 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
+from typing import Any, ClassVar, Dict, List, Optional
+from twitter_openapi_python_generated.models.user_legacy_extended_profile_birthdate import UserLegacyExtendedProfileBirthdate
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserLegacyExtendedProfile(BaseModel):
+    """
+    UserLegacyExtendedProfile
+    """ # noqa: E501
+    birthdate: Optional[UserLegacyExtendedProfileBirthdate] = None
+    __properties: ClassVar[List[str]] = ["birthdate"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of UserLegacyExtendedProfile 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 birthdate
+        if self.birthdate:
+            _dict['birthdate'] = self.birthdate.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UserLegacyExtendedProfile from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "birthdate": UserLegacyExtendedProfileBirthdate.from_dict(obj["birthdate"]) if obj.get("birthdate") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/user_legacy_extended_profile_birthdate.py

@@ -0,0 +1,110 @@
+# 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, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserLegacyExtendedProfileBirthdate(BaseModel):
+    """
+    UserLegacyExtendedProfileBirthdate
+    """ # noqa: E501
+    day: StrictInt
+    month: StrictInt
+    visibility: StrictStr
+    year: StrictInt
+    year_visibility: StrictStr
+    __properties: ClassVar[List[str]] = ["day", "month", "visibility", "year", "year_visibility"]
+
+    @field_validator('visibility')
+    def visibility_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['Self', 'Public', 'MutualFollow', 'Followers', 'Following']):
+            raise ValueError("must be one of enum values ('Self', 'Public', 'MutualFollow', 'Followers', 'Following')")
+        return value
+
+    @field_validator('year_visibility')
+    def year_visibility_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['Self', 'Public', 'MutualFollow', 'Followers', 'Following']):
+            raise ValueError("must be one of enum values ('Self', 'Public', 'MutualFollow', 'Followers', 'Following')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of UserLegacyExtendedProfileBirthdate 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UserLegacyExtendedProfileBirthdate from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "day": obj.get("day"),
+            "month": obj.get("month"),
+            "visibility": obj.get("visibility"),
+            "year": obj.get("year"),
+            "year_visibility": obj.get("year_visibility")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/user_tip_jar_settings.py

@@ -0,0 +1,100 @@
+# 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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserTipJarSettings(BaseModel):
+    """
+    UserTipJarSettings
+    """ # noqa: E501
+    bitcoin_handle: Optional[StrictStr] = None
+    cash_app_handle: Optional[StrictStr] = None
+    ethereum_handle: Optional[StrictStr] = None
+    gofundme_handle: Optional[StrictStr] = None
+    is_enabled: Optional[StrictBool] = None
+    patreon_handle: Optional[StrictStr] = None
+    venmo_handle: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["bitcoin_handle", "cash_app_handle", "ethereum_handle", "gofundme_handle", "is_enabled", "patreon_handle", "venmo_handle"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of UserTipJarSettings 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UserTipJarSettings from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "bitcoin_handle": obj.get("bitcoin_handle"),
+            "cash_app_handle": obj.get("cash_app_handle"),
+            "ethereum_handle": obj.get("ethereum_handle"),
+            "gofundme_handle": obj.get("gofundme_handle"),
+            "is_enabled": obj.get("is_enabled"),
+            "patreon_handle": obj.get("patreon_handle"),
+            "venmo_handle": obj.get("venmo_handle")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/user_union.py

@@ -21,7 +21,7 @@ from typing import Any, List, Optional
 from twitter_openapi_python_generated.models.user import User
 from twitter_openapi_python_generated.models.user_unavailable import UserUnavailable
 from pydantic import StrictStr, Field
-from typing import Union, List, Optional, Dict
+from typing import Union, List, Set, Optional, Dict
 from typing_extensions import Literal, Self
 
 USERUNION_ONE_OF_SCHEMAS = ["User", "UserUnavailable"]
@@ -35,7 +35,7 @@ class UserUnion(BaseModel):
     # data type: UserUnavailable
     oneof_schema_2_validator: Optional[UserUnavailable] = None
     actual_instance: Optional[Union[User, UserUnavailable]] = None
-    one_of_schemas: List[str] = Field(default=Literal["User", "UserUnavailable"])
+    one_of_schemas: Set[str] = { "User", "UserUnavailable" }
 
     model_config = ConfigDict(
         validate_assignment=True,

twitter_openapi_python_generated/rest.py

@@ -203,6 +203,8 @@ class RESTClientObject:
                     # Content-Type which generated by urllib3 will be
                     # overwritten.
                     del headers['Content-Type']
+                    # Ensures that dict objects are serialized
+                    post_params = [(a, json.dumps(b)) if isinstance(b, dict) else (a,b) for a, b in post_params]
                     r = self.pool_manager.request(
                         method,
                         url,

{twitter_openapi_python_generated-0.0.15.dist-info → twitter_openapi_python_generated-0.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: twitter-openapi-python-generated
-Version: 0.0.15
+Version: 0.0.16
 Summary: Twitter OpenAPI
 Home-page: https://github.com/fa0311/twitter_openapi_python_generated
 Author: OpenAPI Generator community