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

creatorsapi_python_sdk/models/manufacture_info.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.single_string_valued_attribute import SingleStringValuedAttribute
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ManufactureInfo(BaseModel):
+    """
+    Container for set of attributes that specifies manufacturing related information of a product.
+    """ # noqa: E501
+    item_part_number: Optional[SingleStringValuedAttribute] = Field(default=None, alias="itemPartNumber")
+    model: Optional[SingleStringValuedAttribute] = None
+    warranty: Optional[SingleStringValuedAttribute] = None
+    __properties: ClassVar[List[str]] = ["itemPartNumber", "model", "warranty"]
+
+    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 ManufactureInfo 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 item_part_number
+        if self.item_part_number:
+            _dict['itemPartNumber'] = self.item_part_number.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of model
+        if self.model:
+            _dict['model'] = self.model.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of warranty
+        if self.warranty:
+            _dict['warranty'] = self.warranty.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ManufactureInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "itemPartNumber": SingleStringValuedAttribute.from_dict(obj["itemPartNumber"]) if obj.get("itemPartNumber") is not None else None,
+            "model": SingleStringValuedAttribute.from_dict(obj["model"]) if obj.get("model") is not None else None,
+            "warranty": SingleStringValuedAttribute.from_dict(obj["warranty"]) if obj.get("warranty") is not None else None
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/money.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, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Money(BaseModel):
+    """
+    Used to return the information about the Money value or amount. Consists of the integral value, the currency codes and the formatted price which can be used for display purposes.
+    """ # noqa: E501
+    amount: Optional[Union[StrictFloat, StrictInt]] = None
+    currency: Optional[StrictStr] = None
+    display_amount: Optional[StrictStr] = Field(default=None, alias="displayAmount")
+    __properties: ClassVar[List[str]] = ["amount", "currency", "displayAmount"]
+
+    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 Money 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 Money from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "amount": obj.get("amount"),
+            "currency": obj.get("currency"),
+            "displayAmount": obj.get("displayAmount")
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/multi_valued_attribute.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, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MultiValuedAttribute(BaseModel):
+    """
+    Container for attributes of multi-valued type.
+    """ # noqa: E501
+    display_values: Optional[List[StrictStr]] = Field(default=None, description="List of primitive string type.", 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 MultiValuedAttribute 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 MultiValuedAttribute from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "displayValues": obj.get("displayValues"),
+            "label": obj.get("label"),
+            "locale": obj.get("locale")
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/offer_availability_v2.py

@@ -0,0 +1,98 @@
+# 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 typing import Optional, Set
+from typing_extensions import Self
+
+class OfferAvailabilityV2(BaseModel):
+    """
+    Specifies availability information about an offer.
+    """ # noqa: E501
+    message: Optional[StrictStr] = None
+    max_order_quantity: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="maxOrderQuantity")
+    min_order_quantity: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="minOrderQuantity")
+    type: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["message", "maxOrderQuantity", "minOrderQuantity", "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 OfferAvailabilityV2 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 OfferAvailabilityV2 from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "message": obj.get("message"),
+            "maxOrderQuantity": obj.get("maxOrderQuantity"),
+            "minOrderQuantity": obj.get("minOrderQuantity"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/offer_condition_v2.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, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OfferConditionV2(BaseModel):
+    """
+    Specifies the condition of the offer.
+    """ # noqa: E501
+    value: Optional[StrictStr] = None
+    sub_condition: Optional[StrictStr] = Field(default=None, alias="subCondition")
+    condition_note: Optional[StrictStr] = Field(default=None, alias="conditionNote")
+    __properties: ClassVar[List[str]] = ["value", "subCondition", "conditionNote"]
+
+    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 OfferConditionV2 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 OfferConditionV2 from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "value": obj.get("value"),
+            "subCondition": obj.get("subCondition"),
+            "conditionNote": obj.get("conditionNote")
+        })
+        return _obj
+
+

creatorsapi_python_sdk/models/offer_listing_v2.py

@@ -0,0 +1,133 @@
+# 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, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from creatorsapi_python_sdk.models.deal_details import DealDetails
+from creatorsapi_python_sdk.models.offer_availability_v2 import OfferAvailabilityV2
+from creatorsapi_python_sdk.models.offer_condition_v2 import OfferConditionV2
+from creatorsapi_python_sdk.models.offer_loyalty_points_v2 import OfferLoyaltyPointsV2
+from creatorsapi_python_sdk.models.offer_merchant_info_v2 import OfferMerchantInfoV2
+from creatorsapi_python_sdk.models.offer_price_v2 import OfferPriceV2
+from creatorsapi_python_sdk.models.offer_type import OfferType
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OfferListingV2(BaseModel):
+    """
+    Specifies about various offer listings associated with the product.
+    """ # noqa: E501
+    availability: Optional[OfferAvailabilityV2] = None
+    condition: Optional[OfferConditionV2] = None
+    deal_details: Optional[DealDetails] = Field(default=None, alias="dealDetails")
+    is_buy_box_winner: Optional[StrictBool] = Field(default=None, alias="isBuyBoxWinner")
+    loyalty_points: Optional[OfferLoyaltyPointsV2] = Field(default=None, alias="loyaltyPoints")
+    merchant_info: Optional[OfferMerchantInfoV2] = Field(default=None, alias="merchantInfo")
+    price: Optional[OfferPriceV2] = None
+    type: Optional[OfferType] = None
+    violates_map: Optional[StrictBool] = Field(default=None, alias="violatesMAP")
+    __properties: ClassVar[List[str]] = ["availability", "condition", "dealDetails", "isBuyBoxWinner", "loyaltyPoints", "merchantInfo", "price", "type", "violatesMAP"]
+
+    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 OfferListingV2 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 availability
+        if self.availability:
+            _dict['availability'] = self.availability.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of condition
+        if self.condition:
+            _dict['condition'] = self.condition.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of deal_details
+        if self.deal_details:
+            _dict['dealDetails'] = self.deal_details.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of loyalty_points
+        if self.loyalty_points:
+            _dict['loyaltyPoints'] = self.loyalty_points.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of merchant_info
+        if self.merchant_info:
+            _dict['merchantInfo'] = self.merchant_info.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of price
+        if self.price:
+            _dict['price'] = self.price.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OfferListingV2 from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "availability": OfferAvailabilityV2.from_dict(obj["availability"]) if obj.get("availability") is not None else None,
+            "condition": OfferConditionV2.from_dict(obj["condition"]) if obj.get("condition") is not None else None,
+            "dealDetails": DealDetails.from_dict(obj["dealDetails"]) if obj.get("dealDetails") is not None else None,
+            "isBuyBoxWinner": obj.get("isBuyBoxWinner"),
+            "loyaltyPoints": OfferLoyaltyPointsV2.from_dict(obj["loyaltyPoints"]) if obj.get("loyaltyPoints") is not None else None,
+            "merchantInfo": OfferMerchantInfoV2.from_dict(obj["merchantInfo"]) if obj.get("merchantInfo") is not None else None,
+            "price": OfferPriceV2.from_dict(obj["price"]) if obj.get("price") is not None else None,
+            "type": obj.get("type"),
+            "violatesMAP": obj.get("violatesMAP")
+        })
+        return _obj
+
+