twitter-openapi-python-generated 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

twitter_openapi_python_generated/models/article_content_entity_value.py

@@ -0,0 +1,104 @@
+# 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, field_validator
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.article_content_entity_data import ArticleContentEntityData
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ArticleContentEntityValue(BaseModel):
+    """
+    ArticleContentEntityValue
+    """ # noqa: E501
+    data: ArticleContentEntityData
+    mutability: StrictStr
+    type: StrictStr
+    __properties: ClassVar[List[str]] = ["data", "mutability", "type"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['MEDIA', 'TWEMOJI', 'TWEET']):
+            raise ValueError("must be one of enum values ('MEDIA', 'TWEMOJI', 'TWEET')")
+        return value
+
+    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 ArticleContentEntityValue 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 data
+        if self.data:
+            _dict['data'] = self.data.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ArticleContentEntityValue from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "data": ArticleContentEntityData.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "mutability": obj.get("mutability"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/article_content_inline_style_range.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, StrictInt, StrictStr, field_validator
+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 ArticleContentInlineStyleRange(BaseModel):
+    """
+    ArticleContentInlineStyleRange
+    """ # noqa: E501
+    length: StrictInt
+    offset: StrictInt
+    style: StrictStr
+    __properties: ClassVar[List[str]] = ["length", "offset", "style"]
+
+    @field_validator('style')
+    def style_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['Bold', 'Italic']):
+            raise ValueError("must be one of enum values ('Bold', 'Italic')")
+        return value
+
+    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 ArticleContentInlineStyleRange 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 ArticleContentInlineStyleRange from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "length": obj.get("length"),
+            "offset": obj.get("offset"),
+            "style": obj.get("style")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/article_content_media_item.py

@@ -0,0 +1,101 @@
+# 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, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ArticleContentMediaItem(BaseModel):
+    """
+    ArticleContentMediaItem
+    """ # noqa: E501
+    local_media_id: StrictStr = Field(alias="localMediaId")
+    media_category: StrictStr = Field(alias="mediaCategory")
+    media_id: Annotated[str, Field(strict=True)] = Field(alias="mediaId")
+    __properties: ClassVar[List[str]] = ["localMediaId", "mediaCategory", "mediaId"]
+
+    @field_validator('media_id', mode="before")
+    def media_id_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if isinstance(value, str) and not re.match(r"^[0-9]+$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+$/")
+        return value
+
+    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 ArticleContentMediaItem 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 ArticleContentMediaItem from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "localMediaId": obj.get("localMediaId"),
+            "mediaCategory": obj.get("mediaCategory"),
+            "mediaId": obj.get("mediaId")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/article_content_state.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
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.article_content_block import ArticleContentBlock
+from twitter_openapi_python_generated.models.article_content_entity import ArticleContentEntity
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ArticleContentState(BaseModel):
+    """
+    ArticleContentState
+    """ # noqa: E501
+    blocks: List[ArticleContentBlock]
+    entity_map: List[ArticleContentEntity] = Field(alias="entityMap")
+    __properties: ClassVar[List[str]] = ["blocks", "entityMap"]
+
+    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 ArticleContentState 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 blocks (list)
+        _items = []
+        if self.blocks:
+            for _item_blocks in self.blocks:
+                _items.append(_item_blocks.to_dict() if _item_blocks is not None else None)
+            _dict['blocks'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in entity_map (list)
+        _items = []
+        if self.entity_map:
+            for _item_entity_map in self.entity_map:
+                _items.append(_item_entity_map.to_dict() if _item_entity_map is not None else None)
+            _dict['entityMap'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ArticleContentState from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "blocks": [ArticleContentBlock.from_dict(_item) for _item in obj["blocks"]] if obj.get("blocks") is not None else None,
+            "entityMap": [ArticleContentEntity.from_dict(_item) for _item in obj["entityMap"]] if obj.get("entityMap") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/article_content_text_range.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, StrictInt, 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 ArticleContentTextRange(BaseModel):
+    """
+    ArticleContentTextRange
+    """ # noqa: E501
+    from_index: StrictInt = Field(alias="fromIndex")
+    text: StrictStr
+    to_index: StrictInt = Field(alias="toIndex")
+    __properties: ClassVar[List[str]] = ["fromIndex", "text", "toIndex"]
+
+    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 ArticleContentTextRange 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 ArticleContentTextRange from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "fromIndex": obj.get("fromIndex"),
+            "text": obj.get("text"),
+            "toIndex": obj.get("toIndex")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/article_result.py

@@ -21,6 +21,7 @@ import json
 from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
 from typing_extensions import Annotated
+from twitter_openapi_python_generated.models.article_content_state import ArticleContentState
 from twitter_openapi_python_generated.models.article_cover_media import ArticleCoverMedia
 from twitter_openapi_python_generated.models.article_lifecycle_state import ArticleLifecycleState
 from twitter_openapi_python_generated.models.article_metadata import ArticleMetadata
@@ -32,7 +33,7 @@ class ArticleResult(BaseModel):
     """
     ArticleResult
     """ # noqa: E501
-    content_state: Optional[Dict[str, Any]] = None
+    content_state: Optional[ArticleContentState] = None
     cover_media: Optional[ArticleCoverMedia] = None
     id: StrictStr
     is_grok_summary_eligible: Optional[StrictBool] = None
@@ -41,8 +42,9 @@ class ArticleResult(BaseModel):
     metadata: ArticleMetadata
     preview_text: StrictStr
     rest_id: Annotated[str, Field(strict=True)]
+    summary_text: Optional[StrictStr] = None
     title: StrictStr
-    __properties: ClassVar[List[str]] = ["content_state", "cover_media", "id", "is_grok_summary_eligible", "lifecycle_state", "media_entities", "metadata", "preview_text", "rest_id", "title"]
+    __properties: ClassVar[List[str]] = ["content_state", "cover_media", "id", "is_grok_summary_eligible", "lifecycle_state", "media_entities", "metadata", "preview_text", "rest_id", "summary_text", "title"]
 
     @field_validator('rest_id', mode="before")
     def rest_id_validate_regular_expression(cls, value):
@@ -90,6 +92,9 @@ class ArticleResult(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of content_state
+        if self.content_state:
+            _dict['content_state'] = self.content_state.to_dict()
         # override the default output from pydantic by calling `to_dict()` of cover_media
         if self.cover_media:
             _dict['cover_media'] = self.cover_media.to_dict()
@@ -117,7 +122,7 @@ class ArticleResult(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "content_state": obj.get("content_state"),
+            "content_state": ArticleContentState.from_dict(obj["content_state"]) if obj.get("content_state") is not None else None,
             "cover_media": ArticleCoverMedia.from_dict(obj["cover_media"]) if obj.get("cover_media") is not None else None,
             "id": obj.get("id"),
             "is_grok_summary_eligible": obj.get("is_grok_summary_eligible"),
@@ -126,6 +131,7 @@ class ArticleResult(BaseModel):
             "metadata": ArticleMetadata.from_dict(obj["metadata"]) if obj.get("metadata") is not None else None,
             "preview_text": obj.get("preview_text"),
             "rest_id": obj.get("rest_id"),
+            "summary_text": obj.get("summary_text"),
             "title": obj.get("title")
         })
         return _obj

twitter_openapi_python_generated/models/audio_space.py

@@ -0,0 +1,107 @@
+# 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
+from typing import Any, ClassVar, Dict, List, Optional
+from twitter_openapi_python_generated.models.audio_space_metadata import AudioSpaceMetadata
+from twitter_openapi_python_generated.models.audio_space_participants import AudioSpaceParticipants
+from twitter_openapi_python_generated.models.audio_space_sharings import AudioSpaceSharings
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class AudioSpace(BaseModel):
+    """
+    AudioSpace
+    """ # noqa: E501
+    is_subscribed: StrictBool
+    metadata: AudioSpaceMetadata
+    participants: AudioSpaceParticipants
+    sharings: Optional[AudioSpaceSharings] = None
+    __properties: ClassVar[List[str]] = ["is_subscribed", "metadata", "participants", "sharings"]
+
+    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 AudioSpace 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 metadata
+        if self.metadata:
+            _dict['metadata'] = self.metadata.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of participants
+        if self.participants:
+            _dict['participants'] = self.participants.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of sharings
+        if self.sharings:
+            _dict['sharings'] = self.sharings.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AudioSpace from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "is_subscribed": obj.get("is_subscribed"),
+            "metadata": AudioSpaceMetadata.from_dict(obj["metadata"]) if obj.get("metadata") is not None else None,
+            "participants": AudioSpaceParticipants.from_dict(obj["participants"]) if obj.get("participants") is not None else None,
+            "sharings": AudioSpaceSharings.from_dict(obj["sharings"]) if obj.get("sharings") is not None else None
+        })
+        return _obj
+
+