amazon-creatorsapi-python-sdk 1.0.0__py3-none-any.whl

creatorsapi_python_sdk/models/item_info.py

@@ -0,0 +1,156 @@
+# coding: utf-8
+
+"""
+Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may not use this file except in compliance with the License.
+A copy of the License is located at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+or in the "license" file accompanying this file. This file is distributed
+on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+
+"""  # noqa: E501
+
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from creatorsapi_python_sdk.models.by_line_info import ByLineInfo
+from creatorsapi_python_sdk.models.classifications import Classifications
+from creatorsapi_python_sdk.models.content_info import ContentInfo
+from creatorsapi_python_sdk.models.content_rating import ContentRating
+from creatorsapi_python_sdk.models.external_ids import ExternalIds
+from creatorsapi_python_sdk.models.manufacture_info import ManufactureInfo
+from creatorsapi_python_sdk.models.multi_valued_attribute import MultiValuedAttribute
+from creatorsapi_python_sdk.models.product_info import ProductInfo
+from creatorsapi_python_sdk.models.single_string_valued_attribute import SingleStringValuedAttribute
+from creatorsapi_python_sdk.models.technical_info import TechnicalInfo
+from creatorsapi_python_sdk.models.trade_in_info import TradeInInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ItemInfo(BaseModel):
+    """
+    Container for ItemInfo high level resource which is a collection of large number of attributes describing a product.
+    """ # noqa: E501
+    by_line_info: Optional[ByLineInfo] = Field(default=None, alias="byLineInfo")
+    classifications: Optional[Classifications] = None
+    content_info: Optional[ContentInfo] = Field(default=None, alias="contentInfo")
+    content_rating: Optional[ContentRating] = Field(default=None, alias="contentRating")
+    external_ids: Optional[ExternalIds] = Field(default=None, alias="externalIds")
+    features: Optional[MultiValuedAttribute] = None
+    manufacture_info: Optional[ManufactureInfo] = Field(default=None, alias="manufactureInfo")
+    product_info: Optional[ProductInfo] = Field(default=None, alias="productInfo")
+    technical_info: Optional[TechnicalInfo] = Field(default=None, alias="technicalInfo")
+    title: Optional[SingleStringValuedAttribute] = None
+    trade_in_info: Optional[TradeInInfo] = Field(default=None, alias="tradeInInfo")
+    __properties: ClassVar[List[str]] = ["byLineInfo", "classifications", "contentInfo", "contentRating", "externalIds", "features", "manufactureInfo", "productInfo", "technicalInfo", "title", "tradeInInfo"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return self.model_dump_json(by_alias=True, exclude_unset=True)
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ItemInfo 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 by_line_info
+        if self.by_line_info:
+            _dict['byLineInfo'] = self.by_line_info.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of classifications
+        if self.classifications:
+            _dict['classifications'] = self.classifications.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of content_info
+        if self.content_info:
+            _dict['contentInfo'] = self.content_info.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of content_rating
+        if self.content_rating:
+            _dict['contentRating'] = self.content_rating.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of external_ids
+        if self.external_ids:
+            _dict['externalIds'] = self.external_ids.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of features
+        if self.features:
+            _dict['features'] = self.features.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of manufacture_info
+        if self.manufacture_info:
+            _dict['manufactureInfo'] = self.manufacture_info.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of product_info
+        if self.product_info:
+            _dict['productInfo'] = self.product_info.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of technical_info
+        if self.technical_info:
+            _dict['technicalInfo'] = self.technical_info.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of title
+        if self.title:
+            _dict['title'] = self.title.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of trade_in_info
+        if self.trade_in_info:
+            _dict['tradeInInfo'] = self.trade_in_info.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ItemInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "byLineInfo": ByLineInfo.from_dict(obj["byLineInfo"]) if obj.get("byLineInfo") is not None else None,
+            "classifications": Classifications.from_dict(obj["classifications"]) if obj.get("classifications") is not None else None,
+            "contentInfo": ContentInfo.from_dict(obj["contentInfo"]) if obj.get("contentInfo") is not None else None,
+            "contentRating": ContentRating.from_dict(obj["contentRating"]) if obj.get("contentRating") is not None else None,
+            "externalIds": ExternalIds.from_dict(obj["externalIds"]) if obj.get("externalIds") is not None else None,
+            "features": MultiValuedAttribute.from_dict(obj["features"]) if obj.get("features") is not None else None,
+            "manufactureInfo": ManufactureInfo.from_dict(obj["manufactureInfo"]) if obj.get("manufactureInfo") is not None else None,
+            "productInfo": ProductInfo.from_dict(obj["productInfo"]) if obj.get("productInfo") is not None else None,
+            "technicalInfo": TechnicalInfo.from_dict(obj["technicalInfo"]) if obj.get("technicalInfo") is not None else None,
+            "title": SingleStringValuedAttribute.from_dict(obj["title"]) if obj.get("title") is not None else None,
+            "tradeInInfo": TradeInInfo.from_dict(obj["tradeInInfo"]) if obj.get("tradeInInfo") is not None else None
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/items_result.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+"""
+Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may not use this file except in compliance with the License.
+A copy of the License is located at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+or in the "license" file accompanying this file. This file is distributed
+on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+
+"""  # noqa: E501
+
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from creatorsapi_python_sdk.models.item import Item
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ItemsResult(BaseModel):
+    """
+    The container for Items response. It consists of resultant Items for the GetItems request.
+    """ # noqa: E501
+    items: Optional[List[Item]] = Field(default=None, description="List of Item which is a container for item information.")
+    __properties: ClassVar[List[str]] = ["items"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return self.model_dump_json(by_alias=True, exclude_unset=True)
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ItemsResult 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 items (list)
+        _items = []
+        if self.items:
+            for _item_items in self.items:
+                if _item_items:
+                    _items.append(_item_items.to_dict())
+            _dict['items'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ItemsResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "items": [Item.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/language_type.py

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may not use this file except in compliance with the License.
+A copy of the License is located at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+or in the "license" file accompanying this file. This file is distributed
+on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+
+"""  # noqa: E501
+
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LanguageType(BaseModel):
+    """
+    Container for language type used to describe the language value associated with the item.
+    """ # noqa: E501
+    display_value: Optional[StrictStr] = Field(default=None, alias="displayValue")
+    type: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["displayValue", "type"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return self.model_dump_json(by_alias=True, exclude_unset=True)
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of LanguageType 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 LanguageType from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "displayValue": obj.get("displayValue"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/languages.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may not use this file except in compliance with the License.
+A copy of the License is located at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+or in the "license" file accompanying this file. This file is distributed
+on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+
+"""  # noqa: E501
+
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from creatorsapi_python_sdk.models.language_type import LanguageType
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Languages(BaseModel):
+    """
+    Container for languages associated with the product.
+    """ # noqa: E501
+    display_values: Optional[List[LanguageType]] = Field(default=None, description="List of language types.", alias="displayValues")
+    label: Optional[StrictStr] = None
+    locale: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["displayValues", "label", "locale"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return self.model_dump_json(by_alias=True, exclude_unset=True)
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of Languages 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 display_values (list)
+        _items = []
+        if self.display_values:
+            for _item_display_values in self.display_values:
+                if _item_display_values:
+                    _items.append(_item_display_values.to_dict())
+            _dict['displayValues'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Languages from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "displayValues": [LanguageType.from_dict(_item) for _item in obj["displayValues"]] if obj.get("displayValues") is not None else None,
+            "label": obj.get("label"),
+            "locale": obj.get("locale")
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/list_feeds_response_content.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+"""
+Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may not use this file except in compliance with the License.
+A copy of the License is located at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+or in the "license" file accompanying this file. This file is distributed
+on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+
+"""  # noqa: E501
+
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from creatorsapi_python_sdk.models.feed import Feed
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ListFeedsResponseContent(BaseModel):
+    """
+    ListFeedsResponseContent
+    """ # noqa: E501
+    feeds: Optional[List[Feed]] = None
+    __properties: ClassVar[List[str]] = ["feeds"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return self.model_dump_json(by_alias=True, exclude_unset=True)
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ListFeedsResponseContent 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 feeds (list)
+        _items = []
+        if self.feeds:
+            for _item_feeds in self.feeds:
+                if _item_feeds:
+                    _items.append(_item_feeds.to_dict())
+            _dict['feeds'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ListFeedsResponseContent from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "feeds": [Feed.from_dict(_item) for _item in obj["feeds"]] if obj.get("feeds") is not None else None
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/list_reports_response_content.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+"""
+Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may not use this file except in compliance with the License.
+A copy of the License is located at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+or in the "license" file accompanying this file. This file is distributed
+on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+
+"""  # noqa: E501
+
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from creatorsapi_python_sdk.models.report_metadata import ReportMetadata
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ListReportsResponseContent(BaseModel):
+    """
+    ListReportsResponseContent
+    """ # noqa: E501
+    reports: List[ReportMetadata]
+    __properties: ClassVar[List[str]] = ["reports"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return self.model_dump_json(by_alias=True, exclude_unset=True)
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ListReportsResponseContent 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 reports (list)
+        _items = []
+        if self.reports:
+            for _item_reports in self.reports:
+                if _item_reports:
+                    _items.append(_item_reports.to_dict())
+            _dict['reports'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ListReportsResponseContent from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "reports": [ReportMetadata.from_dict(_item) for _item in obj["reports"]] if obj.get("reports") is not None else None
+        })
+        return _obj
+
+