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

twitter_openapi_python_generated/models/bookmarks_response.py

@@ -80,8 +80,7 @@ class BookmarksResponse(BaseModel):
         _items = []
         if self.errors:
             for _item_errors in self.errors:
-                if _item_errors:
-                    _items.append(_item_errors.to_dict())
+                _items.append(_item_errors.to_dict() if _item_errors is not None else None)
             _dict['errors'] = _items
         return _dict
 

twitter_openapi_python_generated/models/cashtag_attachment.py

@@ -0,0 +1,89 @@
+# 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, 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 CashtagAttachment(BaseModel):
+    """
+    CashtagAttachment
+    """ # noqa: E501
+    rest_id: StrictStr
+    __properties: ClassVar[List[str]] = ["rest_id"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CashtagAttachment 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 CashtagAttachment from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "rest_id": obj.get("rest_id")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/cashtag_info.py

@@ -0,0 +1,93 @@
+# 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, 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 CashtagInfo(BaseModel):
+    """
+    CashtagInfo
+    """ # noqa: E501
+    name: StrictStr
+    ticker: StrictStr
+    tradable_platforms: List[StrictStr]
+    __properties: ClassVar[List[str]] = ["name", "ticker", "tradable_platforms"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CashtagInfo 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 CashtagInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "ticker": obj.get("ticker"),
+            "tradable_platforms": obj.get("tradable_platforms")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/click_tracking_info.py

@@ -0,0 +1,96 @@
+# 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, Field
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.key_value import KeyValue
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ClickTrackingInfo(BaseModel):
+    """
+    ClickTrackingInfo
+    """ # noqa: E501
+    url_params: List[KeyValue] = Field(alias="urlParams")
+    __properties: ClassVar[List[str]] = ["urlParams"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ClickTrackingInfo 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 url_params (list)
+        _items = []
+        if self.url_params:
+            for _item_url_params in self.url_params:
+                _items.append(_item_url_params.to_dict() if _item_url_params is not None else None)
+            _dict['urlParams'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ClickTrackingInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "urlParams": [KeyValue.from_dict(_item) for _item in obj["urlParams"]] if obj.get("urlParams") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/client_event_info.py

@@ -20,6 +20,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
+from twitter_openapi_python_generated.models.client_event_info_details import ClientEventInfoDetails
 from typing import Optional, Set
 from typing_extensions import Self
 from pydantic_core import to_jsonable_python
@@ -29,7 +30,7 @@ class ClientEventInfo(BaseModel):
     ClientEventInfo
     """ # noqa: E501
     component: Optional[StrictStr] = None
-    details: Optional[Dict[str, Any]] = None
+    details: Optional[ClientEventInfoDetails] = None
     element: Optional[StrictStr] = None
     __properties: ClassVar[List[str]] = ["component", "details", "element"]
 
@@ -72,6 +73,9 @@ class ClientEventInfo(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of details
+        if self.details:
+            _dict['details'] = self.details.to_dict()
         return _dict
 
     @classmethod
@@ -85,7 +89,7 @@ class ClientEventInfo(BaseModel):
 
         _obj = cls.model_validate({
             "component": obj.get("component"),
-            "details": obj.get("details"),
+            "details": ClientEventInfoDetails.from_dict(obj["details"]) if obj.get("details") is not None else None,
             "element": obj.get("element")
         })
         return _obj

twitter_openapi_python_generated/models/client_event_info_details.py

@@ -0,0 +1,99 @@
+# 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, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from twitter_openapi_python_generated.models.conversation_details import ConversationDetails
+from twitter_openapi_python_generated.models.timelines_details import TimelinesDetails
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ClientEventInfoDetails(BaseModel):
+    """
+    ClientEventInfoDetails
+    """ # noqa: E501
+    conversation_details: Optional[ConversationDetails] = Field(default=None, alias="conversationDetails")
+    timelines_details: TimelinesDetails = Field(alias="timelinesDetails")
+    __properties: ClassVar[List[str]] = ["conversationDetails", "timelinesDetails"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ClientEventInfoDetails 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 conversation_details
+        if self.conversation_details:
+            _dict['conversationDetails'] = self.conversation_details.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of timelines_details
+        if self.timelines_details:
+            _dict['timelinesDetails'] = self.timelines_details.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ClientEventInfoDetails from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "conversationDetails": ConversationDetails.from_dict(obj["conversationDetails"]) if obj.get("conversationDetails") is not None else None,
+            "timelinesDetails": TimelinesDetails.from_dict(obj["timelinesDetails"]) if obj.get("timelinesDetails") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/community.py

@@ -22,10 +22,12 @@ from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, Strict
 from typing import Any, ClassVar, Dict, List, Optional
 from typing_extensions import Annotated
 from twitter_openapi_python_generated.models.community_actions import CommunityActions
+from twitter_openapi_python_generated.models.community_banner_media import CommunityBannerMedia
 from twitter_openapi_python_generated.models.community_invites_result import CommunityInvitesResult
 from twitter_openapi_python_generated.models.community_join_requests_result import CommunityJoinRequestsResult
 from twitter_openapi_python_generated.models.community_rule import CommunityRule
 from twitter_openapi_python_generated.models.community_urls import CommunityUrls
+from twitter_openapi_python_generated.models.community_viewer_relationship import CommunityViewerRelationship
 from twitter_openapi_python_generated.models.primary_community_topic import PrimaryCommunityTopic
 from twitter_openapi_python_generated.models.type_name import TypeName
 from twitter_openapi_python_generated.models.user_results import UserResults
@@ -42,8 +44,8 @@ class Community(BaseModel):
     admin_results: Optional[UserResults] = None
     created_at: Optional[StrictInt] = None
     creator_results: Optional[UserResults] = None
-    custom_banner_media: Optional[Dict[str, Any]] = None
-    default_banner_media: Optional[Dict[str, Any]] = None
+    custom_banner_media: Optional[CommunityBannerMedia] = None
+    default_banner_media: Optional[CommunityBannerMedia] = None
     description: Optional[StrictStr] = None
     id_str: Optional[Annotated[str, Field(strict=True)]] = None
     invites_policy: Optional[StrictStr] = None
@@ -62,19 +64,16 @@ class Community(BaseModel):
     search_tags: Optional[List[StrictStr]] = None
     show_only_users_to_display: Optional[List[StrictStr]] = None
     urls: Optional[CommunityUrls] = None
-    viewer_relationship: Optional[Dict[str, Any]] = None
+    viewer_relationship: Optional[CommunityViewerRelationship] = None
     __properties: ClassVar[List[str]] = ["__typename", "actions", "admin_results", "created_at", "creator_results", "custom_banner_media", "default_banner_media", "description", "id_str", "invites_policy", "invites_result", "is_pinned", "join_policy", "join_requests_result", "member_count", "members_facepile_results", "moderator_count", "name", "primary_community_topic", "question", "role", "rules", "search_tags", "show_only_users_to_display", "urls", "viewer_relationship"]
 
-    @field_validator('id_str')
+    @field_validator('id_str', mode="before")
     def id_str_validate_regular_expression(cls, value):
         """Validates the regular expression"""
         if value is None:
             return value
 
-        if not isinstance(value, str):
-            value = str(value)
-
-        if not re.match(r"^[0-9]+$", value):
+        if isinstance(value, str) and not re.match(r"^[0-9]+$", value):
             raise ValueError(r"must validate the regular expression /^[0-9]+$/")
         return value
 
@@ -156,6 +155,12 @@ class Community(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of creator_results
         if self.creator_results:
             _dict['creator_results'] = self.creator_results.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of custom_banner_media
+        if self.custom_banner_media:
+            _dict['custom_banner_media'] = self.custom_banner_media.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of default_banner_media
+        if self.default_banner_media:
+            _dict['default_banner_media'] = self.default_banner_media.to_dict()
         # override the default output from pydantic by calling `to_dict()` of invites_result
         if self.invites_result:
             _dict['invites_result'] = self.invites_result.to_dict()
@@ -166,8 +171,7 @@ class Community(BaseModel):
         _items = []
         if self.members_facepile_results:
             for _item_members_facepile_results in self.members_facepile_results:
-                if _item_members_facepile_results:
-                    _items.append(_item_members_facepile_results.to_dict())
+                _items.append(_item_members_facepile_results.to_dict() if _item_members_facepile_results is not None else None)
             _dict['members_facepile_results'] = _items
         # override the default output from pydantic by calling `to_dict()` of primary_community_topic
         if self.primary_community_topic:
@@ -176,12 +180,14 @@ class Community(BaseModel):
         _items = []
         if self.rules:
             for _item_rules in self.rules:
-                if _item_rules:
-                    _items.append(_item_rules.to_dict())
+                _items.append(_item_rules.to_dict() if _item_rules is not None else None)
             _dict['rules'] = _items
         # override the default output from pydantic by calling `to_dict()` of urls
         if self.urls:
             _dict['urls'] = self.urls.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of viewer_relationship
+        if self.viewer_relationship:
+            _dict['viewer_relationship'] = self.viewer_relationship.to_dict()
         return _dict
 
     @classmethod
@@ -199,8 +205,8 @@ class Community(BaseModel):
             "admin_results": UserResults.from_dict(obj["admin_results"]) if obj.get("admin_results") is not None else None,
             "created_at": obj.get("created_at"),
             "creator_results": UserResults.from_dict(obj["creator_results"]) if obj.get("creator_results") is not None else None,
-            "custom_banner_media": obj.get("custom_banner_media"),
-            "default_banner_media": obj.get("default_banner_media"),
+            "custom_banner_media": CommunityBannerMedia.from_dict(obj["custom_banner_media"]) if obj.get("custom_banner_media") is not None else None,
+            "default_banner_media": CommunityBannerMedia.from_dict(obj["default_banner_media"]) if obj.get("default_banner_media") is not None else None,
             "description": obj.get("description"),
             "id_str": obj.get("id_str"),
             "invites_policy": obj.get("invites_policy"),
@@ -219,7 +225,7 @@ class Community(BaseModel):
             "search_tags": obj.get("search_tags"),
             "show_only_users_to_display": obj.get("show_only_users_to_display"),
             "urls": CommunityUrls.from_dict(obj["urls"]) if obj.get("urls") is not None else None,
-            "viewer_relationship": obj.get("viewer_relationship")
+            "viewer_relationship": CommunityViewerRelationship.from_dict(obj["viewer_relationship"]) if obj.get("viewer_relationship") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/community_about_timeline_response.py

@@ -80,8 +80,7 @@ class CommunityAboutTimelineResponse(BaseModel):
         _items = []
         if self.errors:
             for _item_errors in self.errors:
-                if _item_errors:
-                    _items.append(_item_errors.to_dict())
+                _items.append(_item_errors.to_dict() if _item_errors is not None else None)
             _dict['errors'] = _items
         return _dict
 

twitter_openapi_python_generated/models/community_banner_media.py

@@ -0,0 +1,95 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from twitter_openapi_python_generated.models.community_banner_media_info import CommunityBannerMediaInfo
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CommunityBannerMedia(BaseModel):
+    """
+    CommunityBannerMedia
+    """ # noqa: E501
+    id: Optional[StrictStr] = None
+    media_info: CommunityBannerMediaInfo
+    __properties: ClassVar[List[str]] = ["id", "media_info"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CommunityBannerMedia 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 media_info
+        if self.media_info:
+            _dict['media_info'] = self.media_info.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CommunityBannerMedia from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "media_info": CommunityBannerMediaInfo.from_dict(obj["media_info"]) if obj.get("media_info") is not None else None
+        })
+        return _obj
+
+