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

creatorsapi_python_sdk/models/get_variations_response_content.py

@@ -0,0 +1,106 @@
+# 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.error_data import ErrorData
+from creatorsapi_python_sdk.models.variations_result import VariationsResult
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetVariationsResponseContent(BaseModel):
+    """
+    The response object for the get variations operation.
+    """ # noqa: E501
+    variations_result: Optional[VariationsResult] = Field(default=None, alias="variationsResult")
+    errors: Optional[List[ErrorData]] = Field(default=None, description="List of partial errors encountered during request processing in an otherwise successful response")
+    __properties: ClassVar[List[str]] = ["variationsResult", "errors"]
+
+    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 GetVariationsResponseContent 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 variations_result
+        if self.variations_result:
+            _dict['variationsResult'] = self.variations_result.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+        _items = []
+        if self.errors:
+            for _item_errors in self.errors:
+                if _item_errors:
+                    _items.append(_item_errors.to_dict())
+            _dict['errors'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetVariationsResponseContent from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "variationsResult": VariationsResult.from_dict(obj["variationsResult"]) if obj.get("variationsResult") is not None else None,
+            "errors": [ErrorData.from_dict(_item) for _item in obj["errors"]] if obj.get("errors") is not None else None
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/image_size.py

@@ -0,0 +1,96 @@
+# 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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ImageSize(BaseModel):
+    """
+    Container for image attributes like URL, height and width for a particular image size of a particular image type.
+    """ # noqa: E501
+    url: Optional[StrictStr] = None
+    height: Optional[Union[StrictFloat, StrictInt]] = None
+    width: Optional[Union[StrictFloat, StrictInt]] = None
+    __properties: ClassVar[List[str]] = ["url", "height", "width"]
+
+    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 ImageSize 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 ImageSize from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "url": obj.get("url"),
+            "height": obj.get("height"),
+            "width": obj.get("width")
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/image_type.py

@@ -0,0 +1,111 @@
+# 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.image_size import ImageSize
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ImageType(BaseModel):
+    """
+    Container for image sizes associated with an image type. Images are returned in various sizes like small, medium and large.
+    """ # noqa: E501
+    small: Optional[ImageSize] = None
+    medium: Optional[ImageSize] = None
+    large: Optional[ImageSize] = None
+    hi_res: Optional[ImageSize] = Field(default=None, alias="hiRes")
+    __properties: ClassVar[List[str]] = ["small", "medium", "large", "hiRes"]
+
+    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 ImageType 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 small
+        if self.small:
+            _dict['small'] = self.small.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of medium
+        if self.medium:
+            _dict['medium'] = self.medium.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of large
+        if self.large:
+            _dict['large'] = self.large.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of hi_res
+        if self.hi_res:
+            _dict['hiRes'] = self.hi_res.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ImageType from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "small": ImageSize.from_dict(obj["small"]) if obj.get("small") is not None else None,
+            "medium": ImageSize.from_dict(obj["medium"]) if obj.get("medium") is not None else None,
+            "large": ImageSize.from_dict(obj["large"]) if obj.get("large") is not None else None,
+            "hiRes": ImageSize.from_dict(obj["hiRes"]) if obj.get("hiRes") is not None else None
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/images.py

@@ -0,0 +1,105 @@
+# 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.image_type import ImageType
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Images(BaseModel):
+    """
+    Container for image information associated with a product. Includes url, size, and other image attributes.
+    """ # noqa: E501
+    primary: Optional[ImageType] = None
+    variants: Optional[List[ImageType]] = Field(default=None, description="List of image type which identifies a image as Primary and Variant. Primary denotes the image which is displayed in search results and on the detail page. Variant includes everything else.")
+    __properties: ClassVar[List[str]] = ["primary", "variants"]
+
+    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 Images 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 primary
+        if self.primary:
+            _dict['primary'] = self.primary.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in variants (list)
+        _items = []
+        if self.variants:
+            for _item_variants in self.variants:
+                if _item_variants:
+                    _items.append(_item_variants.to_dict())
+            _dict['variants'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Images from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "primary": ImageType.from_dict(obj["primary"]) if obj.get("primary") is not None else None,
+            "variants": [ImageType.from_dict(_item) for _item in obj["variants"]] if obj.get("variants") is not None else None
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/internal_server_exception_response_content.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 InternalServerExceptionResponseContent(BaseModel):
+    """
+    Unexpected error during processing of request. Clients should retry with exponential backoff.
+    """ # noqa: E501
+    type: Optional[StrictStr] = Field(default=None, description="The exception type identifier for clients to programmatically identify the exception")
+    message: StrictStr
+    __properties: ClassVar[List[str]] = ["type", "message"]
+
+    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 InternalServerExceptionResponseContent 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 InternalServerExceptionResponseContent from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "message": obj.get("message")
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/item.py

@@ -0,0 +1,138 @@
+# 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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from creatorsapi_python_sdk.models.browse_node_info import BrowseNodeInfo
+from creatorsapi_python_sdk.models.customer_reviews import CustomerReviews
+from creatorsapi_python_sdk.models.images import Images
+from creatorsapi_python_sdk.models.item_info import ItemInfo
+from creatorsapi_python_sdk.models.offers_v2 import OffersV2
+from creatorsapi_python_sdk.models.variation_attribute import VariationAttribute
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Item(BaseModel):
+    """
+    Container for item information such as ASIN, Detail Page URL and other attributes. It also includes containers for various item related resources like Images, ItemInfo, etc.
+    """ # noqa: E501
+    asin: Optional[StrictStr] = None
+    browse_node_info: Optional[BrowseNodeInfo] = Field(default=None, alias="browseNodeInfo")
+    customer_reviews: Optional[CustomerReviews] = Field(default=None, alias="customerReviews")
+    detail_page_url: Optional[StrictStr] = Field(default=None, alias="detailPageURL")
+    images: Optional[Images] = None
+    item_info: Optional[ItemInfo] = Field(default=None, alias="itemInfo")
+    offers_v2: Optional[OffersV2] = Field(default=None, alias="offersV2")
+    parent_asin: Optional[StrictStr] = Field(default=None, alias="parentASIN")
+    score: Optional[Union[StrictFloat, StrictInt]] = None
+    variation_attributes: Optional[List[VariationAttribute]] = Field(default=None, description="List of offer listing associated with a product.", alias="variationAttributes")
+    __properties: ClassVar[List[str]] = ["asin", "browseNodeInfo", "customerReviews", "detailPageURL", "images", "itemInfo", "offersV2", "parentASIN", "score", "variationAttributes"]
+
+    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 Item 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 browse_node_info
+        if self.browse_node_info:
+            _dict['browseNodeInfo'] = self.browse_node_info.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of customer_reviews
+        if self.customer_reviews:
+            _dict['customerReviews'] = self.customer_reviews.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of images
+        if self.images:
+            _dict['images'] = self.images.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of item_info
+        if self.item_info:
+            _dict['itemInfo'] = self.item_info.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of offers_v2
+        if self.offers_v2:
+            _dict['offersV2'] = self.offers_v2.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in variation_attributes (list)
+        _items = []
+        if self.variation_attributes:
+            for _item_variation_attributes in self.variation_attributes:
+                if _item_variation_attributes:
+                    _items.append(_item_variation_attributes.to_dict())
+            _dict['variationAttributes'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Item from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "asin": obj.get("asin"),
+            "browseNodeInfo": BrowseNodeInfo.from_dict(obj["browseNodeInfo"]) if obj.get("browseNodeInfo") is not None else None,
+            "customerReviews": CustomerReviews.from_dict(obj["customerReviews"]) if obj.get("customerReviews") is not None else None,
+            "detailPageURL": obj.get("detailPageURL"),
+            "images": Images.from_dict(obj["images"]) if obj.get("images") is not None else None,
+            "itemInfo": ItemInfo.from_dict(obj["itemInfo"]) if obj.get("itemInfo") is not None else None,
+            "offersV2": OffersV2.from_dict(obj["offersV2"]) if obj.get("offersV2") is not None else None,
+            "parentASIN": obj.get("parentASIN"),
+            "score": obj.get("score"),
+            "variationAttributes": [VariationAttribute.from_dict(_item) for _item in obj["variationAttributes"]] if obj.get("variationAttributes") is not None else None
+        })
+        return _obj
+
+