twitter-openapi-python-generated 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

twitter_openapi_python_generated/models/urt_endpoint_options.py

@@ -0,0 +1,98 @@
+# 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, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.urt_endpoint_request_params import UrtEndpointRequestParams
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UrtEndpointOptions(BaseModel):
+    """
+    UrtEndpointOptions
+    """ # noqa: E501
+    request_params: List[UrtEndpointRequestParams] = Field(alias="requestParams")
+    title: StrictStr
+    __properties: ClassVar[List[str]] = ["requestParams", "title"]
+
+    model_config = {
+        "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 UrtEndpointOptions 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 each item in request_params (list)
+        _items = []
+        if self.request_params:
+            for _item in self.request_params:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['requestParams'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UrtEndpointOptions from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "requestParams": [UrtEndpointRequestParams.from_dict(_item) for _item in obj["requestParams"]] if obj.get("requestParams") is not None else None,
+            "title": obj.get("title")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/urt_endpoint_request_params.py

@@ -0,0 +1,90 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UrtEndpointRequestParams(BaseModel):
+    """
+    UrtEndpointRequestParams
+    """ # noqa: E501
+    key: StrictStr
+    value: StrictStr
+    __properties: ClassVar[List[str]] = ["key", "value"]
+
+    model_config = {
+        "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 UrtEndpointRequestParams 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 UrtEndpointRequestParams from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "key": obj.get("key"),
+            "value": obj.get("value")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/user.py

@@ -18,17 +18,16 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, Field, StrictBool, StrictInt, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
-from pydantic import BaseModel, StrictBool, field_validator
-from pydantic import Field
 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
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from twitter_openapi_python_generated.models.user_professional import UserProfessional
+from twitter_openapi_python_generated.models.user_verification_info import UserVerificationInfo
+from typing import Optional, Set
+from typing_extensions import Self
 
 class User(BaseModel):
     """
@@ -37,16 +36,23 @@ class User(BaseModel):
     typename: TypeName = Field(alias="__typename")
     affiliates_highlighted_label: Dict[str, Any]
     business_account: Optional[Dict[str, Any]] = None
+    creator_subscriptions_count: Optional[StrictInt] = None
     has_graduated_access: Optional[StrictBool] = None
     has_nft_avatar: Optional[StrictBool] = False
+    highlights_info: Optional[UserHighlightsInfo] = None
     id: Annotated[str, Field(strict=True)]
     is_blue_verified: StrictBool
+    is_profile_translatable: Optional[StrictBool] = None
     legacy: UserLegacy
+    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
-    __properties: ClassVar[List[str]] = ["__typename", "affiliates_highlighted_label", "business_account", "has_graduated_access", "has_nft_avatar", "id", "is_blue_verified", "legacy", "rest_id", "super_follow_eligible", "super_followed_by", "super_following"]
+    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"]
 
     @field_validator('id')
     def id_validate_regular_expression(cls, value):
@@ -55,6 +61,13 @@ class User(BaseModel):
             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
 
+    @field_validator('profile_image_shape')
+    def profile_image_shape_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['Circle', 'Square', 'Hexagon']):
+            raise ValueError("must be one of enum values ('Circle', 'Square', 'Hexagon')")
+        return value
+
     @field_validator('rest_id')
     def rest_id_validate_regular_expression(cls, value):
         """Validates the regular expression"""
@@ -79,7 +92,7 @@ class User(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of User from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -93,19 +106,30 @@ class User(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of highlights_info
+        if self.highlights_info:
+            _dict['highlights_info'] = self.highlights_info.to_dict()
         # 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 professional
+        if self.professional:
+            _dict['professional'] = self.professional.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()
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of User from a dict"""
         if obj is None:
             return None
@@ -117,15 +141,22 @@ class User(BaseModel):
             "__typename": obj.get("__typename"),
             "affiliates_highlighted_label": obj.get("affiliates_highlighted_label"),
             "business_account": obj.get("business_account"),
+            "creator_subscriptions_count": obj.get("creator_subscriptions_count"),
             "has_graduated_access": obj.get("has_graduated_access"),
             "has_nft_avatar": obj.get("has_nft_avatar") if obj.get("has_nft_avatar") is not None else False,
+            "highlights_info": UserHighlightsInfo.from_dict(obj["highlights_info"]) if obj.get("highlights_info") is not None else None,
             "id": obj.get("id"),
             "is_blue_verified": obj.get("is_blue_verified") if obj.get("is_blue_verified") is not None else False,
-            "legacy": UserLegacy.from_dict(obj.get("legacy")) if obj.get("legacy") is not None else None,
+            "is_profile_translatable": obj.get("is_profile_translatable"),
+            "legacy": UserLegacy.from_dict(obj["legacy"]) if obj.get("legacy") 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
+            "super_following": obj.get("super_following") if obj.get("super_following") is not None else False,
+            "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
         })
         return _obj
 

twitter_openapi_python_generated/models/user_features.py

@@ -18,13 +18,10 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Any, ClassVar, Dict, List
 from pydantic import BaseModel, StrictBool
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
 
 class UserFeatures(BaseModel):
     """
@@ -50,7 +47,7 @@ class UserFeatures(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of UserFeatures from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -64,16 +61,18 @@ class UserFeatures(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of UserFeatures from a dict"""
         if obj is None:
             return None

twitter_openapi_python_generated/models/user_highlights_info.py

@@ -0,0 +1,90 @@
+# 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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserHighlightsInfo(BaseModel):
+    """
+    UserHighlightsInfo
+    """ # noqa: E501
+    can_highlight_tweets: StrictBool
+    highlighted_tweets: StrictStr
+    __properties: ClassVar[List[str]] = ["can_highlight_tweets", "highlighted_tweets"]
+
+    model_config = {
+        "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 UserHighlightsInfo 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 UserHighlightsInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "can_highlight_tweets": obj.get("can_highlight_tweets"),
+            "highlighted_tweets": obj.get("highlighted_tweets")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/user_highlights_tweets_data.py

@@ -18,14 +18,11 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Any, ClassVar, Dict, List
 from pydantic import BaseModel
+from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.user_highlights_tweets_user import UserHighlightsTweetsUser
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class UserHighlightsTweetsData(BaseModel):
     """
@@ -51,7 +48,7 @@ class UserHighlightsTweetsData(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of UserHighlightsTweetsData from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -65,10 +62,12 @@ class UserHighlightsTweetsData(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of user
@@ -77,7 +76,7 @@ class UserHighlightsTweetsData(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of UserHighlightsTweetsData from a dict"""
         if obj is None:
             return None
@@ -86,7 +85,7 @@ class UserHighlightsTweetsData(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "user": UserHighlightsTweetsUser.from_dict(obj.get("user")) if obj.get("user") is not None else None
+            "user": UserHighlightsTweetsUser.from_dict(obj["user"]) if obj.get("user") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/user_highlights_tweets_response.py

@@ -18,14 +18,11 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Any, ClassVar, Dict, List
 from pydantic import BaseModel
+from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.user_highlights_tweets_data import UserHighlightsTweetsData
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class UserHighlightsTweetsResponse(BaseModel):
     """
@@ -51,7 +48,7 @@ class UserHighlightsTweetsResponse(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of UserHighlightsTweetsResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -65,10 +62,12 @@ class UserHighlightsTweetsResponse(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of data
@@ -77,7 +76,7 @@ class UserHighlightsTweetsResponse(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of UserHighlightsTweetsResponse from a dict"""
         if obj is None:
             return None
@@ -86,7 +85,7 @@ class UserHighlightsTweetsResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": UserHighlightsTweetsData.from_dict(obj.get("data")) if obj.get("data") is not None else None
+            "data": UserHighlightsTweetsData.from_dict(obj["data"]) if obj.get("data") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/user_highlights_tweets_result.py

@@ -18,16 +18,12 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, Field
 from typing import Any, ClassVar, Dict, List
-from pydantic import BaseModel
-from pydantic import Field
 from twitter_openapi_python_generated.models.type_name import TypeName
 from twitter_openapi_python_generated.models.user_highlights_tweets_timeline import UserHighlightsTweetsTimeline
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class UserHighlightsTweetsResult(BaseModel):
     """
@@ -54,7 +50,7 @@ class UserHighlightsTweetsResult(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of UserHighlightsTweetsResult from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -68,10 +64,12 @@ class UserHighlightsTweetsResult(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of timeline
@@ -80,7 +78,7 @@ class UserHighlightsTweetsResult(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of UserHighlightsTweetsResult from a dict"""
         if obj is None:
             return None
@@ -90,7 +88,7 @@ class UserHighlightsTweetsResult(BaseModel):
 
         _obj = cls.model_validate({
             "__typename": obj.get("__typename"),
-            "timeline": UserHighlightsTweetsTimeline.from_dict(obj.get("timeline")) if obj.get("timeline") is not None else None
+            "timeline": UserHighlightsTweetsTimeline.from_dict(obj["timeline"]) if obj.get("timeline") is not None else None
         })
         return _obj