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

twitter_openapi_python_generated/models/tweet_legacy_place.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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.tweet_legacy_place_bounding_box import TweetLegacyPlaceBoundingBox
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class TweetLegacyPlace(BaseModel):
+    """
+    TweetLegacyPlace
+    """ # noqa: E501
+    bounding_box: TweetLegacyPlaceBoundingBox
+    country: StrictStr
+    country_code: StrictStr
+    full_name: StrictStr
+    id: StrictStr
+    name: StrictStr
+    place_type: StrictStr
+    url: StrictStr
+    __properties: ClassVar[List[str]] = ["bounding_box", "country", "country_code", "full_name", "id", "name", "place_type", "url"]
+
+    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 TweetLegacyPlace 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 bounding_box
+        if self.bounding_box:
+            _dict['bounding_box'] = self.bounding_box.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TweetLegacyPlace from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "bounding_box": TweetLegacyPlaceBoundingBox.from_dict(obj["bounding_box"]) if obj.get("bounding_box") is not None else None,
+            "country": obj.get("country"),
+            "country_code": obj.get("country_code"),
+            "full_name": obj.get("full_name"),
+            "id": obj.get("id"),
+            "name": obj.get("name"),
+            "place_type": obj.get("place_type"),
+            "url": obj.get("url")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/tweet_legacy_place_bounding_box.py

@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+    Twitter OpenAPI
+
+    Twitter OpenAPI(Swagger) specification
+
+    The version of the OpenAPI document: 0.0.1
+    Contact: yuki@yuki0311.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class TweetLegacyPlaceBoundingBox(BaseModel):
+    """
+    TweetLegacyPlaceBoundingBox
+    """ # noqa: E501
+    coordinates: List[List[List[Union[StrictFloat, StrictInt]]]]
+    type: StrictStr
+    __properties: ClassVar[List[str]] = ["coordinates", "type"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['Polygon']):
+            raise ValueError("must be one of enum values ('Polygon')")
+        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 TweetLegacyPlaceBoundingBox 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 TweetLegacyPlaceBoundingBox from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "coordinates": obj.get("coordinates"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/tweet_legacy_point.py

@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+    Twitter OpenAPI
+
+    Twitter OpenAPI(Swagger) specification
+
+    The version of the OpenAPI document: 0.0.1
+    Contact: yuki@yuki0311.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class TweetLegacyPoint(BaseModel):
+    """
+    TweetLegacyPoint
+    """ # noqa: E501
+    coordinates: List[Union[StrictFloat, StrictInt]]
+    type: StrictStr
+    __properties: ClassVar[List[str]] = ["coordinates", "type"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['Point']):
+            raise ValueError("must be one of enum values ('Point')")
+        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 TweetLegacyPoint 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 TweetLegacyPoint from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "coordinates": obj.get("coordinates"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/tweet_post_cta.py

@@ -18,7 +18,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from twitter_openapi_python_generated.models.post_cta import PostCta
 from typing import Optional, Set
@@ -34,14 +34,6 @@ class TweetPostCta(BaseModel):
     scribe_id: Optional[StrictStr] = None
     __properties: ClassVar[List[str]] = ["display_locations", "post_cta", "scribe_id"]
 
-    @field_validator('display_locations')
-    def display_locations_validate_enum(cls, value):
-        """Validates the enum"""
-        for i in value:
-            if i not in set(['TweetDetails', 'ForYouTimeline', 'RepliesTimeline']):
-                raise ValueError("each list item must be one of ('TweetDetails', 'ForYouTimeline', 'RepliesTimeline')")
-        return value
-
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,

twitter_openapi_python_generated/models/tweet_sports_competitor.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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from twitter_openapi_python_generated.models.tweet_sports_rest_id import TweetSportsRestId
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class TweetSportsCompetitor(BaseModel):
+    """
+    TweetSportsCompetitor
+    """ # noqa: E501
+    abbreviation: StrictStr
+    dark_logo_url: StrictStr
+    is_active: StrictBool
+    is_winner: StrictBool
+    logo_url: StrictStr
+    name: StrictStr
+    score: StrictStr
+    team_rest_id: TweetSportsRestId
+    __properties: ClassVar[List[str]] = ["abbreviation", "dark_logo_url", "is_active", "is_winner", "logo_url", "name", "score", "team_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 TweetSportsCompetitor 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 team_rest_id
+        if self.team_rest_id:
+            _dict['team_rest_id'] = self.team_rest_id.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TweetSportsCompetitor from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "abbreviation": obj.get("abbreviation"),
+            "dark_logo_url": obj.get("dark_logo_url"),
+            "is_active": obj.get("is_active"),
+            "is_winner": obj.get("is_winner"),
+            "logo_url": obj.get("logo_url"),
+            "name": obj.get("name"),
+            "score": obj.get("score"),
+            "team_rest_id": TweetSportsRestId.from_dict(obj["team_rest_id"]) if obj.get("team_rest_id") is not None else None
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/tweet_sports_post_context.py

@@ -0,0 +1,122 @@
+# 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 twitter_openapi_python_generated.models.tweet_sports_competitor import TweetSportsCompetitor
+from twitter_openapi_python_generated.models.tweet_sports_rest_id import TweetSportsRestId
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class TweetSportsPostContext(BaseModel):
+    """
+    TweetSportsPostContext
+    """ # noqa: E501
+    competitors: List[TweetSportsCompetitor]
+    game_id: TweetSportsRestId
+    league: StrictStr
+    scheduled_at_ms: Annotated[str, Field(strict=True)]
+    state: StrictStr
+    status_text: StrictStr
+    title: StrictStr
+    url: StrictStr
+    __properties: ClassVar[List[str]] = ["competitors", "game_id", "league", "scheduled_at_ms", "state", "status_text", "title", "url"]
+
+    @field_validator('scheduled_at_ms', mode="before")
+    def scheduled_at_ms_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 TweetSportsPostContext 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 competitors (list)
+        _items = []
+        if self.competitors:
+            for _item_competitors in self.competitors:
+                _items.append(_item_competitors.to_dict() if _item_competitors is not None else None)
+            _dict['competitors'] = _items
+        # override the default output from pydantic by calling `to_dict()` of game_id
+        if self.game_id:
+            _dict['game_id'] = self.game_id.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TweetSportsPostContext from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "competitors": [TweetSportsCompetitor.from_dict(_item) for _item in obj["competitors"]] if obj.get("competitors") is not None else None,
+            "game_id": TweetSportsRestId.from_dict(obj["game_id"]) if obj.get("game_id") is not None else None,
+            "league": obj.get("league"),
+            "scheduled_at_ms": obj.get("scheduled_at_ms"),
+            "state": obj.get("state"),
+            "status_text": obj.get("status_text"),
+            "title": obj.get("title"),
+            "url": obj.get("url")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/tweet_sports_rest_id.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 TweetSportsRestId(BaseModel):
+    """
+    TweetSportsRestId
+    """ # 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 TweetSportsRestId 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 TweetSportsRestId 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/type_name.py

@@ -33,6 +33,8 @@ class TypeName(str, Enum):
     TIMELINETWITTERLIST = 'TimelineTwitterList'
     TIMELINELABEL = 'TimelineLabel'
     TIMELINEEVENTSUMMARY = 'TimelineEventSummary'
+    AITREND = 'AiTrend'
+    TIMELINERICHTEXT = 'TimelineRichText'
     TIMELINETIMELINEITEM = 'TimelineTimelineItem'
     TIMELINEUSER = 'TimelineUser'
     TIMELINETIMELINECURSOR = 'TimelineTimelineCursor'

twitter_openapi_python_generated/models/unified_card.py

@@ -18,7 +18,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, StrictStr
 from typing import Any, ClassVar, Dict, List
 from typing import Optional, Set
 from typing_extensions import Self
@@ -31,13 +31,6 @@ class UnifiedCard(BaseModel):
     card_fetch_state: StrictStr
     __properties: ClassVar[List[str]] = ["card_fetch_state"]
 
-    @field_validator('card_fetch_state')
-    def card_fetch_state_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['NoCard']):
-            raise ValueError("must be one of enum values ('NoCard')")
-        return value
-
     model_config = ConfigDict(
         validate_by_name=True,
         validate_by_alias=True,