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

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

twitter_openapi_python_generated/models/audio_space_mentioned_user.py

@@ -0,0 +1,97 @@
+# 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 typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class AudioSpaceMentionedUser(BaseModel):
+    """
+    AudioSpaceMentionedUser
+    """ # noqa: E501
+    rest_id: Annotated[str, Field(strict=True)]
+    __properties: ClassVar[List[str]] = ["rest_id"]
+
+    @field_validator('rest_id', mode="before")
+    def rest_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 AudioSpaceMentionedUser 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 AudioSpaceMentionedUser 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/audio_space_metadata.py

@@ -0,0 +1,165 @@
+# 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, StrictBool, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from twitter_openapi_python_generated.models.audio_space_mentioned_user import AudioSpaceMentionedUser
+from twitter_openapi_python_generated.models.item_result import ItemResult
+from twitter_openapi_python_generated.models.user_results import UserResults
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class AudioSpaceMetadata(BaseModel):
+    """
+    AudioSpaceMetadata
+    """ # noqa: E501
+    content_type: Optional[StrictStr] = None
+    conversation_controls: StrictInt
+    created_at: StrictInt
+    creator_results: UserResults
+    disallow_join: StrictBool
+    ended_at: Optional[Annotated[str, Field(strict=True)]] = None
+    is_employee_only: StrictBool
+    is_locked: StrictBool
+    is_muted: StrictBool
+    is_space_available_for_clipping: StrictBool
+    is_space_available_for_replay: StrictBool
+    max_admin_capacity: StrictInt
+    max_guest_sessions: StrictInt
+    media_key: StrictStr
+    mentioned_users: Optional[List[AudioSpaceMentionedUser]] = None
+    narrow_cast_space_type: StrictInt
+    no_incognito: StrictBool
+    rest_id: StrictStr
+    scheduled_start: Optional[StrictInt] = None
+    started_at: StrictInt
+    state: StrictStr
+    title: StrictStr
+    total_live_listeners: StrictInt
+    total_replay_watched: StrictInt
+    tweet_results: ItemResult
+    updated_at: StrictInt
+    __properties: ClassVar[List[str]] = ["content_type", "conversation_controls", "created_at", "creator_results", "disallow_join", "ended_at", "is_employee_only", "is_locked", "is_muted", "is_space_available_for_clipping", "is_space_available_for_replay", "max_admin_capacity", "max_guest_sessions", "media_key", "mentioned_users", "narrow_cast_space_type", "no_incognito", "rest_id", "scheduled_start", "started_at", "state", "title", "total_live_listeners", "total_replay_watched", "tweet_results", "updated_at"]
+
+    @field_validator('ended_at', mode="before")
+    def ended_at_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return 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
+
+    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 AudioSpaceMetadata 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 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 each item in mentioned_users (list)
+        _items = []
+        if self.mentioned_users:
+            for _item_mentioned_users in self.mentioned_users:
+                _items.append(_item_mentioned_users.to_dict() if _item_mentioned_users is not None else None)
+            _dict['mentioned_users'] = _items
+        # override the default output from pydantic by calling `to_dict()` of tweet_results
+        if self.tweet_results:
+            _dict['tweet_results'] = self.tweet_results.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AudioSpaceMetadata from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "content_type": obj.get("content_type"),
+            "conversation_controls": obj.get("conversation_controls"),
+            "created_at": obj.get("created_at"),
+            "creator_results": UserResults.from_dict(obj["creator_results"]) if obj.get("creator_results") is not None else None,
+            "disallow_join": obj.get("disallow_join"),
+            "ended_at": obj.get("ended_at"),
+            "is_employee_only": obj.get("is_employee_only"),
+            "is_locked": obj.get("is_locked"),
+            "is_muted": obj.get("is_muted"),
+            "is_space_available_for_clipping": obj.get("is_space_available_for_clipping"),
+            "is_space_available_for_replay": obj.get("is_space_available_for_replay"),
+            "max_admin_capacity": obj.get("max_admin_capacity"),
+            "max_guest_sessions": obj.get("max_guest_sessions"),
+            "media_key": obj.get("media_key"),
+            "mentioned_users": [AudioSpaceMentionedUser.from_dict(_item) for _item in obj["mentioned_users"]] if obj.get("mentioned_users") is not None else None,
+            "narrow_cast_space_type": obj.get("narrow_cast_space_type"),
+            "no_incognito": obj.get("no_incognito"),
+            "rest_id": obj.get("rest_id"),
+            "scheduled_start": obj.get("scheduled_start"),
+            "started_at": obj.get("started_at"),
+            "state": obj.get("state"),
+            "title": obj.get("title"),
+            "total_live_listeners": obj.get("total_live_listeners"),
+            "total_replay_watched": obj.get("total_replay_watched"),
+            "tweet_results": ItemResult.from_dict(obj["tweet_results"]) if obj.get("tweet_results") is not None else None,
+            "updated_at": obj.get("updated_at")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/audio_space_participant.py

@@ -0,0 +1,109 @@
+# 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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from twitter_openapi_python_generated.models.audio_space_participant_user_results import AudioSpaceParticipantUserResults
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class AudioSpaceParticipant(BaseModel):
+    """
+    AudioSpaceParticipant
+    """ # noqa: E501
+    avatar_url: StrictStr
+    display_name: StrictStr
+    is_muted_by_admin: StrictBool
+    is_muted_by_guest: StrictBool
+    is_verified: StrictBool
+    periscope_user_id: StrictStr
+    start: Optional[StrictInt] = None
+    twitter_screen_name: StrictStr
+    user_results: AudioSpaceParticipantUserResults
+    __properties: ClassVar[List[str]] = ["avatar_url", "display_name", "is_muted_by_admin", "is_muted_by_guest", "is_verified", "periscope_user_id", "start", "twitter_screen_name", "user_results"]
+
+    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 AudioSpaceParticipant 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 user_results
+        if self.user_results:
+            _dict['user_results'] = self.user_results.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AudioSpaceParticipant from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "avatar_url": obj.get("avatar_url"),
+            "display_name": obj.get("display_name"),
+            "is_muted_by_admin": obj.get("is_muted_by_admin"),
+            "is_muted_by_guest": obj.get("is_muted_by_guest"),
+            "is_verified": obj.get("is_verified"),
+            "periscope_user_id": obj.get("periscope_user_id"),
+            "start": obj.get("start"),
+            "twitter_screen_name": obj.get("twitter_screen_name"),
+            "user_results": AudioSpaceParticipantUserResults.from_dict(obj["user_results"]) if obj.get("user_results") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/audio_space_participant_user.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, Field, StrictBool
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.audio_space_participant_verification import AudioSpaceParticipantVerification
+from twitter_openapi_python_generated.models.identity_profile_labels_highlighted_label import IdentityProfileLabelsHighlightedLabel
+from twitter_openapi_python_generated.models.type_name import TypeName
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class AudioSpaceParticipantUser(BaseModel):
+    """
+    AudioSpaceParticipantUser
+    """ # noqa: E501
+    typename: TypeName = Field(alias="__typename")
+    identity_profile_labels_highlighted_label: IdentityProfileLabelsHighlightedLabel
+    is_blue_verified: StrictBool
+    verification: AudioSpaceParticipantVerification
+    __properties: ClassVar[List[str]] = ["__typename", "identity_profile_labels_highlighted_label", "is_blue_verified", "verification"]
+
+    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 AudioSpaceParticipantUser 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 identity_profile_labels_highlighted_label
+        if self.identity_profile_labels_highlighted_label:
+            _dict['identity_profile_labels_highlighted_label'] = self.identity_profile_labels_highlighted_label.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of verification
+        if self.verification:
+            _dict['verification'] = self.verification.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AudioSpaceParticipantUser 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"),
+            "identity_profile_labels_highlighted_label": IdentityProfileLabelsHighlightedLabel.from_dict(obj["identity_profile_labels_highlighted_label"]) if obj.get("identity_profile_labels_highlighted_label") is not None else None,
+            "is_blue_verified": obj.get("is_blue_verified"),
+            "verification": AudioSpaceParticipantVerification.from_dict(obj["verification"]) if obj.get("verification") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/audio_space_participant_user_results.py

@@ -0,0 +1,103 @@
+# 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.audio_space_participant_user import AudioSpaceParticipantUser
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class AudioSpaceParticipantUserResults(BaseModel):
+    """
+    AudioSpaceParticipantUserResults
+    """ # noqa: E501
+    rest_id: Annotated[str, Field(strict=True)]
+    result: AudioSpaceParticipantUser
+    __properties: ClassVar[List[str]] = ["rest_id", "result"]
+
+    @field_validator('rest_id', mode="before")
+    def rest_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 AudioSpaceParticipantUserResults 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 AudioSpaceParticipantUserResults 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"),
+            "result": AudioSpaceParticipantUser.from_dict(obj["result"]) if obj.get("result") is not None else None
+        })
+        return _obj
+
+