proxyrequest-sdk 1.0.0__py3-none-any.whl

proxyrequest_sdk/_generated/models/coupon_calculate_price_request.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from uuid import UUID
+
+
+T = TypeVar("T", bound="CouponCalculatePriceRequest")
+
+
+@_attrs_define
+class CouponCalculatePriceRequest:
+    coupon_code: str
+    data: int
+    package_id: UUID | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        coupon_code = self.coupon_code
+
+        data = self.data
+
+        package_id: str | Unset = UNSET
+        if not isinstance(self.package_id, Unset):
+            package_id = str(self.package_id)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "coupon_code": coupon_code,
+                "data": data,
+            }
+        )
+        if package_id is not UNSET:
+            field_dict["package_id"] = package_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        coupon_code = d.pop("coupon_code")
+
+        data = d.pop("data")
+
+        _package_id = d.pop("package_id", UNSET)
+        package_id: UUID | Unset
+        if isinstance(_package_id, Unset):
+            package_id = UNSET
+        else:
+            package_id = UUID(_package_id)
+
+        coupon_calculate_price_request = cls(
+            coupon_code=coupon_code,
+            data=data,
+            package_id=package_id,
+        )
+
+        coupon_calculate_price_request.additional_properties = d
+        return coupon_calculate_price_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

proxyrequest_sdk/_generated/models/coupon_create_request.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.coupon_type_enum import CouponTypeEnum
+from ..types import UNSET, Unset
+from typing import cast
+from uuid import UUID
+import datetime
+
+
+T = TypeVar("T", bound="CouponCreateRequest")
+
+
+@_attrs_define
+class CouponCreateRequest:
+    value: int
+    """ Arbitrary coupon value """
+    type_: CouponTypeEnum
+    """ * `free_data` - Free Data * `monetary` - Money * `percentage` - Percentage """
+    code: str | Unset = UNSET
+    """ Leave empty to auto-generate a code """
+    is_multi_use: bool | Unset = UNSET
+    """ If true, coupon can be used multiple times. """
+    is_available_to_one_time: bool | Unset = UNSET
+    """ If true, coupon can not be used for one-time package tiers. """
+    marketer: None | Unset | UUID = UNSET
+    """ The marketer who owns this coupon. Required if is_marketer is true. """
+    limit: int | Unset = UNSET
+    """ Number of times coupon can be used """
+    valid_until: datetime.datetime | None | Unset = UNSET
+    """ Leave empty for coupons that never expire """
+    packages: list[str] | Unset = UNSET
+    """ Select packages for which this coupon is available. If no packages are selected, the coupon is available to
+    all packages. """
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        value = self.value
+
+        type_ = self.type_.value
+
+        code = self.code
+
+        is_multi_use = self.is_multi_use
+
+        is_available_to_one_time = self.is_available_to_one_time
+
+        marketer: None | str | Unset
+        if isinstance(self.marketer, Unset):
+            marketer = UNSET
+        elif isinstance(self.marketer, UUID):
+            marketer = str(self.marketer)
+        else:
+            marketer = self.marketer
+
+        limit = self.limit
+
+        valid_until: None | str | Unset
+        if isinstance(self.valid_until, Unset):
+            valid_until = UNSET
+        elif isinstance(self.valid_until, datetime.datetime):
+            valid_until = self.valid_until.isoformat()
+        else:
+            valid_until = self.valid_until
+
+        packages: list[str] | Unset = UNSET
+        if not isinstance(self.packages, Unset):
+            packages = self.packages
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "value": value,
+                "type": type_,
+            }
+        )
+        if code is not UNSET:
+            field_dict["code"] = code
+        if is_multi_use is not UNSET:
+            field_dict["is_multi_use"] = is_multi_use
+        if is_available_to_one_time is not UNSET:
+            field_dict["is_available_to_one_time"] = is_available_to_one_time
+        if marketer is not UNSET:
+            field_dict["marketer"] = marketer
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if valid_until is not UNSET:
+            field_dict["valid_until"] = valid_until
+        if packages is not UNSET:
+            field_dict["packages"] = packages
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        value = d.pop("value")
+
+        type_ = CouponTypeEnum(d.pop("type"))
+
+        code = d.pop("code", UNSET)
+
+        is_multi_use = d.pop("is_multi_use", UNSET)
+
+        is_available_to_one_time = d.pop("is_available_to_one_time", UNSET)
+
+        def _parse_marketer(data: object) -> None | Unset | UUID:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                marketer_type_0 = UUID(data)
+
+                return marketer_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | Unset | UUID, data)
+
+        marketer = _parse_marketer(d.pop("marketer", UNSET))
+
+        limit = d.pop("limit", UNSET)
+
+        def _parse_valid_until(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                valid_until_type_0 = datetime.datetime.fromisoformat(data)
+
+                return valid_until_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        valid_until = _parse_valid_until(d.pop("valid_until", UNSET))
+
+        packages = cast(list[str], d.pop("packages", UNSET))
+
+        coupon_create_request = cls(
+            value=value,
+            type_=type_,
+            code=code,
+            is_multi_use=is_multi_use,
+            is_available_to_one_time=is_available_to_one_time,
+            marketer=marketer,
+            limit=limit,
+            valid_until=valid_until,
+            packages=packages,
+        )
+
+        coupon_create_request.additional_properties = d
+        return coupon_create_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

proxyrequest_sdk/_generated/models/coupon_price_response.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+T = TypeVar("T", bound="CouponPriceResponse")
+
+
+@_attrs_define
+class CouponPriceResponse:
+    price_original: int
+    """ Original price in the service's smallest currency unit. """
+    price_discounted: int
+    """ Price after applying the coupon, in the smallest currency unit. """
+    discount_percentage: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        price_original = self.price_original
+
+        price_discounted = self.price_discounted
+
+        discount_percentage = self.discount_percentage
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "price_original": price_original,
+                "price_discounted": price_discounted,
+                "discount_percentage": discount_percentage,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        price_original = d.pop("price_original")
+
+        price_discounted = d.pop("price_discounted")
+
+        discount_percentage = d.pop("discount_percentage")
+
+        coupon_price_response = cls(
+            price_original=price_original,
+            price_discounted=price_discounted,
+            discount_percentage=discount_percentage,
+        )
+
+        coupon_price_response.additional_properties = d
+        return coupon_price_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

proxyrequest_sdk/_generated/models/coupon_redeem.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+from uuid import UUID
+import datetime
+
+
+T = TypeVar("T", bound="CouponRedeem")
+
+
+@_attrs_define
+class CouponRedeem:
+    user: UUID
+    invoice_amount: float | None
+    discount_applied: float | None
+    created: datetime.datetime
+    id: str | Unset = UNSET
+    invoice: None | str | Unset = UNSET
+    redeemed_at: datetime.datetime | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        user = str(self.user)
+
+        invoice_amount: float | None
+        invoice_amount = self.invoice_amount
+
+        discount_applied: float | None
+        discount_applied = self.discount_applied
+
+        created = self.created.isoformat()
+
+        id = self.id
+
+        invoice: None | str | Unset
+        if isinstance(self.invoice, Unset):
+            invoice = UNSET
+        else:
+            invoice = self.invoice
+
+        redeemed_at: None | str | Unset
+        if isinstance(self.redeemed_at, Unset):
+            redeemed_at = UNSET
+        elif isinstance(self.redeemed_at, datetime.datetime):
+            redeemed_at = self.redeemed_at.isoformat()
+        else:
+            redeemed_at = self.redeemed_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "user": user,
+                "invoice_amount": invoice_amount,
+                "discount_applied": discount_applied,
+                "created": created,
+            }
+        )
+        if id is not UNSET:
+            field_dict["id"] = id
+        if invoice is not UNSET:
+            field_dict["invoice"] = invoice
+        if redeemed_at is not UNSET:
+            field_dict["redeemed_at"] = redeemed_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        user = UUID(d.pop("user"))
+
+        def _parse_invoice_amount(data: object) -> float | None:
+            if data is None:
+                return data
+            return cast(float | None, data)
+
+        invoice_amount = _parse_invoice_amount(d.pop("invoice_amount"))
+
+        def _parse_discount_applied(data: object) -> float | None:
+            if data is None:
+                return data
+            return cast(float | None, data)
+
+        discount_applied = _parse_discount_applied(d.pop("discount_applied"))
+
+        created = datetime.datetime.fromisoformat(d.pop("created"))
+
+        id = d.pop("id", UNSET)
+
+        def _parse_invoice(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        invoice = _parse_invoice(d.pop("invoice", UNSET))
+
+        def _parse_redeemed_at(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                redeemed_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return redeemed_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        redeemed_at = _parse_redeemed_at(d.pop("redeemed_at", UNSET))
+
+        coupon_redeem = cls(
+            user=user,
+            invoice_amount=invoice_amount,
+            discount_applied=discount_applied,
+            created=created,
+            id=id,
+            invoice=invoice,
+            redeemed_at=redeemed_at,
+        )
+
+        coupon_redeem.additional_properties = d
+        return coupon_redeem
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties