twitter-openapi-python-generated 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

twitter_openapi_python_generated/models/timeline_timeline_cursor.py

@@ -18,17 +18,14 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, Field, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from pydantic import BaseModel, StrictStr
-from pydantic import Field
 from twitter_openapi_python_generated.models.content_entry_type import ContentEntryType
 from twitter_openapi_python_generated.models.cursor_type import CursorType
+from twitter_openapi_python_generated.models.display_treatment import DisplayTreatment
 from twitter_openapi_python_generated.models.type_name import TypeName
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class TimelineTimelineCursor(BaseModel):
     """
@@ -36,10 +33,12 @@ class TimelineTimelineCursor(BaseModel):
     """ # noqa: E501
     typename: TypeName = Field(alias="__typename")
     cursor_type: CursorType = Field(alias="cursorType")
+    display_treatment: Optional[DisplayTreatment] = Field(default=None, alias="displayTreatment")
     entry_type: Optional[ContentEntryType] = Field(default=None, alias="entryType")
     item_type: Optional[ContentEntryType] = Field(default=None, alias="itemType")
+    stop_on_empty_response: StrictBool = Field(alias="stopOnEmptyResponse")
     value: StrictStr
-    __properties: ClassVar[List[str]] = ["__typename", "cursorType", "entryType", "itemType", "value"]
+    __properties: ClassVar[List[str]] = ["__typename", "cursorType", "displayTreatment", "entryType", "itemType", "stopOnEmptyResponse", "value"]
 
     model_config = {
         "populate_by_name": True,
@@ -58,7 +57,7 @@ class TimelineTimelineCursor(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of TimelineTimelineCursor from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -72,16 +71,21 @@ class TimelineTimelineCursor(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of display_treatment
+        if self.display_treatment:
+            _dict['displayTreatment'] = self.display_treatment.to_dict()
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of TimelineTimelineCursor from a dict"""
         if obj is None:
             return None
@@ -92,8 +96,10 @@ class TimelineTimelineCursor(BaseModel):
         _obj = cls.model_validate({
             "__typename": obj.get("__typename"),
             "cursorType": obj.get("cursorType"),
+            "displayTreatment": DisplayTreatment.from_dict(obj["displayTreatment"]) if obj.get("displayTreatment") is not None else None,
             "entryType": obj.get("entryType"),
             "itemType": obj.get("itemType"),
+            "stopOnEmptyResponse": obj.get("stopOnEmptyResponse") if obj.get("stopOnEmptyResponse") is not None else False,
             "value": obj.get("value")
         })
         return _obj

twitter_openapi_python_generated/models/timeline_timeline_item.py

@@ -18,18 +18,14 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, Field
 from typing import Any, ClassVar, Dict, List, Optional
-from pydantic import BaseModel
-from pydantic import Field
 from twitter_openapi_python_generated.models.client_event_info import ClientEventInfo
 from twitter_openapi_python_generated.models.content_entry_type import ContentEntryType
 from twitter_openapi_python_generated.models.item_content_union import ItemContentUnion
 from twitter_openapi_python_generated.models.type_name import TypeName
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class TimelineTimelineItem(BaseModel):
     """
@@ -59,7 +55,7 @@ class TimelineTimelineItem(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of TimelineTimelineItem from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -73,10 +69,12 @@ class TimelineTimelineItem(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of client_event_info
@@ -88,7 +86,7 @@ class TimelineTimelineItem(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of TimelineTimelineItem from a dict"""
         if obj is None:
             return None
@@ -98,10 +96,10 @@ class TimelineTimelineItem(BaseModel):
 
         _obj = cls.model_validate({
             "__typename": obj.get("__typename"),
-            "clientEventInfo": ClientEventInfo.from_dict(obj.get("clientEventInfo")) if obj.get("clientEventInfo") is not None else None,
+            "clientEventInfo": ClientEventInfo.from_dict(obj["clientEventInfo"]) if obj.get("clientEventInfo") is not None else None,
             "entryType": obj.get("entryType"),
             "feedbackInfo": obj.get("feedbackInfo"),
-            "itemContent": ItemContentUnion.from_dict(obj.get("itemContent")) if obj.get("itemContent") is not None else None
+            "itemContent": ItemContentUnion.from_dict(obj["itemContent"]) if obj.get("itemContent") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/timeline_timeline_module.py

@@ -18,16 +18,14 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, Field, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from pydantic import BaseModel, StrictStr, field_validator
-from pydantic import Field
 from twitter_openapi_python_generated.models.content_entry_type import ContentEntryType
+from twitter_openapi_python_generated.models.display_type import DisplayType
+from twitter_openapi_python_generated.models.feedback_info import FeedbackInfo
 from twitter_openapi_python_generated.models.module_item import ModuleItem
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class TimelineTimelineModule(BaseModel):
     """
@@ -35,19 +33,14 @@ class TimelineTimelineModule(BaseModel):
     """ # noqa: E501
     typename: StrictStr = Field(alias="__typename")
     client_event_info: Dict[str, Any] = Field(alias="clientEventInfo")
-    display_type: StrictStr = Field(alias="displayType")
+    display_type: DisplayType = Field(alias="displayType")
     entry_type: ContentEntryType = Field(alias="entryType")
+    feedback_info: Optional[FeedbackInfo] = Field(default=None, alias="feedbackInfo")
     footer: Optional[Dict[str, Any]] = None
     header: Optional[Dict[str, Any]] = None
     items: Optional[List[ModuleItem]] = None
-    __properties: ClassVar[List[str]] = ["__typename", "clientEventInfo", "displayType", "entryType", "footer", "header", "items"]
-
-    @field_validator('display_type')
-    def display_type_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in ('Vertical', 'VerticalConversation', 'VerticalGrid', 'Carousel'):
-            raise ValueError("must be one of enum values ('Vertical', 'VerticalConversation', 'VerticalGrid', 'Carousel')")
-        return value
+    metadata: Optional[Dict[str, Any]] = None
+    __properties: ClassVar[List[str]] = ["__typename", "clientEventInfo", "displayType", "entryType", "feedbackInfo", "footer", "header", "items", "metadata"]
 
     model_config = {
         "populate_by_name": True,
@@ -66,7 +59,7 @@ class TimelineTimelineModule(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of TimelineTimelineModule from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -80,12 +73,17 @@ class TimelineTimelineModule(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of feedback_info
+        if self.feedback_info:
+            _dict['feedbackInfo'] = self.feedback_info.to_dict()
         # override the default output from pydantic by calling `to_dict()` of each item in items (list)
         _items = []
         if self.items:
@@ -96,7 +94,7 @@ class TimelineTimelineModule(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of TimelineTimelineModule from a dict"""
         if obj is None:
             return None
@@ -109,9 +107,11 @@ class TimelineTimelineModule(BaseModel):
             "clientEventInfo": obj.get("clientEventInfo"),
             "displayType": obj.get("displayType"),
             "entryType": obj.get("entryType"),
+            "feedbackInfo": FeedbackInfo.from_dict(obj["feedbackInfo"]) if obj.get("feedbackInfo") is not None else None,
             "footer": obj.get("footer"),
             "header": obj.get("header"),
-            "items": [ModuleItem.from_dict(_item) for _item in obj.get("items")] if obj.get("items") is not None else None
+            "items": [ModuleItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
+            "metadata": obj.get("metadata")
         })
         return _obj
 

twitter_openapi_python_generated/models/timeline_topic_context.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, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from twitter_openapi_python_generated.models.social_context_union_type import SocialContextUnionType
+from twitter_openapi_python_generated.models.topic_context import TopicContext
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TimelineTopicContext(BaseModel):
+    """
+    TimelineTopicContext
+    """ # noqa: E501
+    functionality_type: Optional[StrictStr] = Field(default=None, alias="functionalityType")
+    topic: Optional[TopicContext] = None
+    type: Optional[SocialContextUnionType] = None
+    __properties: ClassVar[List[str]] = ["functionalityType", "topic", "type"]
+
+    @field_validator('functionality_type')
+    def functionality_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['Basic']):
+            raise ValueError("must be one of enum values ('Basic')")
+        return value
+
+    model_config = {
+        "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 TimelineTopicContext 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 topic
+        if self.topic:
+            _dict['topic'] = self.topic.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TimelineTopicContext from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "functionalityType": obj.get("functionalityType"),
+            "topic": TopicContext.from_dict(obj["topic"]) if obj.get("topic") is not None else None,
+            "type": obj.get("type")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/timeline_tweet.py

@@ -18,30 +18,28 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, Field, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from pydantic import BaseModel, StrictStr
-from pydantic import Field
 from twitter_openapi_python_generated.models.content_item_type import ContentItemType
+from twitter_openapi_python_generated.models.highlight import Highlight
 from twitter_openapi_python_generated.models.item_result import ItemResult
-from twitter_openapi_python_generated.models.social_context import SocialContext
+from twitter_openapi_python_generated.models.social_context_union import SocialContextUnion
 from twitter_openapi_python_generated.models.type_name import TypeName
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class TimelineTweet(BaseModel):
     """
     TimelineTweet
     """ # noqa: E501
-    social_context: Optional[SocialContext] = Field(default=None, alias="SocialContext")
     typename: TypeName = Field(alias="__typename")
+    highlights: Optional[Highlight] = None
     item_type: ContentItemType = Field(alias="itemType")
     promoted_metadata: Optional[Dict[str, Any]] = Field(default=None, alias="promotedMetadata")
+    social_context: Optional[SocialContextUnion] = Field(default=None, alias="socialContext")
     tweet_display_type: StrictStr = Field(alias="tweetDisplayType")
     tweet_results: ItemResult
-    __properties: ClassVar[List[str]] = ["SocialContext", "__typename", "itemType", "promotedMetadata", "tweetDisplayType", "tweet_results"]
+    __properties: ClassVar[List[str]] = ["__typename", "highlights", "itemType", "promotedMetadata", "socialContext", "tweetDisplayType", "tweet_results"]
 
     model_config = {
         "populate_by_name": True,
@@ -60,7 +58,7 @@ class TimelineTweet(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of TimelineTweet from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -74,22 +72,27 @@ class TimelineTweet(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of highlights
+        if self.highlights:
+            _dict['highlights'] = self.highlights.to_dict()
         # override the default output from pydantic by calling `to_dict()` of social_context
         if self.social_context:
-            _dict['SocialContext'] = self.social_context.to_dict()
+            _dict['socialContext'] = self.social_context.to_dict()
         # 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: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of TimelineTweet from a dict"""
         if obj is None:
             return None
@@ -98,12 +101,13 @@ class TimelineTweet(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "SocialContext": SocialContext.from_dict(obj.get("SocialContext")) if obj.get("SocialContext") is not None else None,
             "__typename": obj.get("__typename"),
+            "highlights": Highlight.from_dict(obj["highlights"]) if obj.get("highlights") is not None else None,
             "itemType": obj.get("itemType"),
             "promotedMetadata": obj.get("promotedMetadata"),
+            "socialContext": SocialContextUnion.from_dict(obj["socialContext"]) if obj.get("socialContext") is not None else None,
             "tweetDisplayType": obj.get("tweetDisplayType"),
-            "tweet_results": ItemResult.from_dict(obj.get("tweet_results")) if obj.get("tweet_results") is not None else None
+            "tweet_results": ItemResult.from_dict(obj["tweet_results"]) if obj.get("tweet_results") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/timeline_user.py

@@ -18,34 +18,30 @@ import pprint
 import re  # noqa: F401
 import json
 
-
+from pydantic import BaseModel, Field, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
-from pydantic import BaseModel, StrictStr, field_validator
-from pydantic import Field
 from twitter_openapi_python_generated.models.content_item_type import ContentItemType
-from twitter_openapi_python_generated.models.social_context import SocialContext
+from twitter_openapi_python_generated.models.social_context_union import SocialContextUnion
 from twitter_openapi_python_generated.models.type_name import TypeName
 from twitter_openapi_python_generated.models.user_results import UserResults
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class TimelineUser(BaseModel):
     """
     TimelineUser
     """ # noqa: E501
-    social_context: Optional[SocialContext] = Field(default=None, alias="SocialContext")
     typename: TypeName = Field(alias="__typename")
     item_type: ContentItemType = Field(alias="itemType")
+    social_context: Optional[SocialContextUnion] = Field(default=None, alias="socialContext")
     user_display_type: StrictStr = Field(alias="userDisplayType")
     user_results: UserResults
-    __properties: ClassVar[List[str]] = ["SocialContext", "__typename", "itemType", "userDisplayType", "user_results"]
+    __properties: ClassVar[List[str]] = ["__typename", "itemType", "socialContext", "userDisplayType", "user_results"]
 
     @field_validator('user_display_type')
     def user_display_type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in ('User', 'UserDetailed', 'SubscribableUser'):
+        if value not in set(['User', 'UserDetailed', 'SubscribableUser']):
             raise ValueError("must be one of enum values ('User', 'UserDetailed', 'SubscribableUser')")
         return value
 
@@ -66,7 +62,7 @@ class TimelineUser(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of TimelineUser from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -80,22 +76,24 @@ class TimelineUser(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of social_context
         if self.social_context:
-            _dict['SocialContext'] = self.social_context.to_dict()
+            _dict['socialContext'] = self.social_context.to_dict()
         # 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: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of TimelineUser from a dict"""
         if obj is None:
             return None
@@ -104,11 +102,11 @@ class TimelineUser(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "SocialContext": SocialContext.from_dict(obj.get("SocialContext")) if obj.get("SocialContext") is not None else None,
             "__typename": obj.get("__typename"),
             "itemType": obj.get("itemType"),
+            "socialContext": SocialContextUnion.from_dict(obj["socialContext"]) if obj.get("socialContext") is not None else None,
             "userDisplayType": obj.get("userDisplayType"),
-            "user_results": UserResults.from_dict(obj.get("user_results")) if obj.get("user_results") is not None else None
+            "user_results": UserResults.from_dict(obj["user_results"]) if obj.get("user_results") is not None else None
         })
         return _obj
 

twitter_openapi_python_generated/models/timeline_v2.py

@@ -18,14 +18,11 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Any, ClassVar, Dict, List
 from pydantic import BaseModel
+from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.timeline import Timeline
-try:
-    from typing import Self
-except ImportError:
-    from typing_extensions import Self
+from typing import Optional, Set
+from typing_extensions import Self
 
 class TimelineV2(BaseModel):
     """
@@ -51,7 +48,7 @@ class TimelineV2(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of TimelineV2 from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -65,10 +62,12 @@ class TimelineV2(BaseModel):
           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={
-            },
+            exclude=excluded_fields,
             exclude_none=True,
         )
         # override the default output from pydantic by calling `to_dict()` of timeline
@@ -77,7 +76,7 @@ class TimelineV2(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: Dict) -> Self:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of TimelineV2 from a dict"""
         if obj is None:
             return None
@@ -86,7 +85,7 @@ class TimelineV2(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "timeline": Timeline.from_dict(obj.get("timeline")) if obj.get("timeline") is not None else None
+            "timeline": Timeline.from_dict(obj["timeline"]) if obj.get("timeline") is not None else None
         })
         return _obj