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

twitter_openapi_python_generated/models/media_community_result.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, Field
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.timeline_result import TimelineResult
+from twitter_openapi_python_generated.models.type_name import TypeName
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MediaCommunityResult(BaseModel):
+    """
+    MediaCommunityResult
+    """ # noqa: E501
+    typename: TypeName = Field(alias="__typename")
+    community_media_timeline: TimelineResult
+    __properties: ClassVar[List[str]] = ["__typename", "community_media_timeline"]
+
+    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 MediaCommunityResult 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 community_media_timeline
+        if self.community_media_timeline:
+            _dict['community_media_timeline'] = self.community_media_timeline.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MediaCommunityResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "__typename": obj.get("__typename"),
+            "community_media_timeline": TimelineResult.from_dict(obj["community_media_timeline"]) if obj.get("community_media_timeline") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/media_community_results.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
+from twitter_openapi_python_generated.models.media_community_result import MediaCommunityResult
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MediaCommunityResults(BaseModel):
+    """
+    MediaCommunityResults
+    """ # noqa: E501
+    result: MediaCommunityResult
+    __properties: ClassVar[List[str]] = ["result"]
+
+    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 MediaCommunityResults 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 result
+        if self.result:
+            _dict['result'] = self.result.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MediaCommunityResults from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "result": MediaCommunityResult.from_dict(obj["result"]) if obj.get("result") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/media_community_tweet_data.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, Field
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.media_community_results import MediaCommunityResults
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MediaCommunityTweetData(BaseModel):
+    """
+    MediaCommunityTweetData
+    """ # noqa: E501
+    community_results: MediaCommunityResults = Field(alias="communityResults")
+    __properties: ClassVar[List[str]] = ["communityResults"]
+
+    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 MediaCommunityTweetData 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 community_results
+        if self.community_results:
+            _dict['communityResults'] = self.community_results.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MediaCommunityTweetData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "communityResults": MediaCommunityResults.from_dict(obj["communityResults"]) if obj.get("communityResults") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/media_result.py

@@ -19,7 +19,8 @@ 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 twitter_openapi_python_generated.models.grok_image_annotation import GrokImageAnnotation
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,8 +28,9 @@ class MediaResult(BaseModel):
     """
     MediaResult
     """ # noqa: E501
+    grok_image_annotation: Optional[GrokImageAnnotation] = None
     media_key: StrictStr
-    __properties: ClassVar[List[str]] = ["media_key"]
+    __properties: ClassVar[List[str]] = ["grok_image_annotation", "media_key"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -69,6 +71,9 @@ class MediaResult(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of grok_image_annotation
+        if self.grok_image_annotation:
+            _dict['grok_image_annotation'] = self.grok_image_annotation.to_dict()
         return _dict
 
     @classmethod
@@ -81,6 +86,7 @@ class MediaResult(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "grok_image_annotation": GrokImageAnnotation.from_dict(obj["grok_image_annotation"]) if obj.get("grok_image_annotation") is not None else None,
             "media_key": obj.get("media_key")
         })
         return _obj

twitter_openapi_python_generated/models/module_item.py

@@ -37,8 +37,8 @@ class ModuleItem(BaseModel):
     @field_validator('entry_id')
     def entry_id_validate_regular_expression(cls, value):
         """Validates the regular expression"""
-        if not re.match(r"^(([a-z]+|[0-9]+|[0-9a-f]+)(-|$))+", value):
-            raise ValueError(r"must validate the regular expression /^(([a-z]+|[0-9]+|[0-9a-f]+)(-|$))+/")
+        if not re.match(r"^(([a-zA-Z]+|[0-9]+|[0-9a-f]+)(-|$))+", value):
+            raise ValueError(r"must validate the regular expression /^(([a-zA-Z]+|[0-9]+|[0-9a-f]+)(-|$))+/")
         return value
 
     model_config = ConfigDict(

twitter_openapi_python_generated/models/notification_template.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, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from twitter_openapi_python_generated.models.type_name import TypeName
+from typing import Optional, Set
+from typing_extensions import Self
+
+class NotificationTemplate(BaseModel):
+    """
+    NotificationTemplate
+    """ # noqa: E501
+    typename: Optional[TypeName] = Field(default=None, alias="__typename")
+    from_users: Optional[List[Dict[str, Any]]] = None
+    target_objects: Optional[List[Dict[str, Any]]] = None
+    __properties: ClassVar[List[str]] = ["__typename", "from_users", "target_objects"]
+
+    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 NotificationTemplate 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 NotificationTemplate from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "__typename": obj.get("__typename"),
+            "from_users": obj.get("from_users"),
+            "target_objects": obj.get("target_objects")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/notifications_result.py

@@ -0,0 +1,105 @@
+# 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, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing_extensions import Annotated
+from twitter_openapi_python_generated.models.timeline_result import TimelineResult
+from twitter_openapi_python_generated.models.type_name import TypeName
+from typing import Optional, Set
+from typing_extensions import Self
+
+class NotificationsResult(BaseModel):
+    """
+    NotificationsResult
+    """ # noqa: E501
+    typename: TypeName = Field(alias="__typename")
+    notification_timeline: TimelineResult
+    rest_id: Annotated[str, Field(strict=True)]
+    __properties: ClassVar[List[str]] = ["__typename", "notification_timeline", "rest_id"]
+
+    @field_validator('rest_id')
+    def rest_id_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[0-9]+$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+$/")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_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 NotificationsResult 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 notification_timeline
+        if self.notification_timeline:
+            _dict['notification_timeline'] = self.notification_timeline.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of NotificationsResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "__typename": obj.get("__typename"),
+            "notification_timeline": TimelineResult.from_dict(obj["notification_timeline"]) if obj.get("notification_timeline") is not None else None,
+            "rest_id": obj.get("rest_id")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/notifications_timeline_data.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
+from twitter_openapi_python_generated.models.notifications_viewer_v2 import NotificationsViewerV2
+from typing import Optional, Set
+from typing_extensions import Self
+
+class NotificationsTimelineData(BaseModel):
+    """
+    NotificationsTimelineData
+    """ # noqa: E501
+    viewer_v2: NotificationsViewerV2
+    __properties: ClassVar[List[str]] = ["viewer_v2"]
+
+    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 NotificationsTimelineData 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 viewer_v2
+        if self.viewer_v2:
+            _dict['viewer_v2'] = self.viewer_v2.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of NotificationsTimelineData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "viewer_v2": NotificationsViewerV2.from_dict(obj["viewer_v2"]) if obj.get("viewer_v2") is not None else None
+        })
+        return _obj
+
+