9113607451

Committed 16 May 2024 01:55PM UTC coverage: 96.391% (+0.02%) from 96.375%

Build # 9113607451

Build Type

Pull #1328

github

Committed by

web-flow

Commit Message

Merge 06c2f6603 into 46edbe3eb

Pull Request Pull Request #1328: Update generated code

Run Details

1288 of 1901 branches covered (67.75%)

Branch coverage included in aggregate %.

149 of 150 new or added lines in 18 files covered. (99.33%)

803 existing lines in 91 files now uncovered.

64356 of 66201 relevant lines covered (97.21%)

0.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.31

/stripe/_coupon.py

# -*- coding: utf-8 -*-
# File generated from our OpenAPI spec
from stripe._createable_api_resource import CreateableAPIResource
from stripe._deletable_api_resource import DeletableAPIResource
from stripe._list_object import ListObject
from stripe._listable_api_resource import ListableAPIResource
from stripe._request_options import RequestOptions
from stripe._stripe_object import StripeObject
from stripe._updateable_api_resource import UpdateableAPIResource
from stripe._util import class_method_variant, sanitize_id
from typing import ClassVar, Dict, List, Optional, cast, overload
from typing_extensions import Literal, NotRequired, TypedDict, Unpack


class Coupon(
    CreateableAPIResource["Coupon"],
    DeletableAPIResource["Coupon"],
    ListableAPIResource["Coupon"],
    UpdateableAPIResource["Coupon"],
):
    """
    A coupon contains information about a percent-off or amount-off discount you
    might want to apply to a customer. Coupons may be applied to [subscriptions](https://stripe.com/docs/api#subscriptions), [invoices](https://stripe.com/docs/api#invoices),
    [checkout sessions](https://stripe.com/docs/api/checkout/sessions), [quotes](https://stripe.com/docs/api#quotes), and more. Coupons do not work with conventional one-off [charges](https://stripe.com/docs/api#create_charge) or [payment intents](https://stripe.com/docs/api/payment_intents).
    """

    OBJECT_NAME: ClassVar[Literal["coupon"]] = "coupon"

    class AppliesTo(StripeObject):
        products: List[str]
        """
        A list of product IDs this coupon applies to
        """

    class CurrencyOptions(StripeObject):
        amount_off: int
        """
        Amount (in the `currency` specified) that will be taken off the subtotal of any invoices for this customer.
        """

    class CreateParams(RequestOptions):
        amount_off: NotRequired[int]
        """
        A positive integer representing the amount to subtract from an invoice total (required if `percent_off` is not passed).
        """
        applies_to: NotRequired["Coupon.CreateParamsAppliesTo"]
        """
        A hash containing directions for what this Coupon will apply discounts to.
        """
        currency: NotRequired[str]
        """
        Three-letter [ISO code for the currency](https://stripe.com/docs/currencies) of the `amount_off` parameter (required if `amount_off` is passed).
        """
        currency_options: NotRequired[
            Dict[str, "Coupon.CreateParamsCurrencyOptions"]
        ]
        """
        Coupons defined in each available currency option (only supported if `amount_off` is passed). Each key must be a three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html) and a [supported currency](https://stripe.com/docs/currencies).
        """
        duration: NotRequired[Literal["forever", "once", "repeating"]]
        """
        Specifies how long the discount will be in effect if used on a subscription. Defaults to `once`.
        """
        duration_in_months: NotRequired[int]
        """
        Required only if `duration` is `repeating`, in which case it must be a positive integer that specifies the number of months the discount will be in effect.
        """
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """
        id: NotRequired[str]
        """
        Unique string of your choice that will be used to identify this coupon when applying it to a customer. If you don't want to specify a particular code, you can leave the ID blank and we'll generate a random code for you.
        """
        max_redemptions: NotRequired[int]
        """
        A positive integer specifying the number of times the coupon can be redeemed before it's no longer valid. For example, you might have a 50% off coupon that the first 20 readers of your blog can use.
        """
        metadata: NotRequired["Literal['']|Dict[str, str]"]
        """
        Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
        """
        name: NotRequired[str]
        """
        Name of the coupon displayed to customers on, for instance invoices, or receipts. By default the `id` is shown if `name` is not set.
        """
        percent_off: NotRequired[float]
        """
        A positive float larger than 0, and smaller or equal to 100, that represents the discount the coupon will apply (required if `amount_off` is not passed).
        """
        redeem_by: NotRequired[int]
        """
        Unix timestamp specifying the last time at which the coupon can be redeemed. After the redeem_by date, the coupon can no longer be applied to new customers.
        """

    class CreateParamsAppliesTo(TypedDict):
        products: NotRequired[List[str]]
        """
        An array of Product IDs that this Coupon will apply to.
        """

    class CreateParamsCurrencyOptions(TypedDict):
        amount_off: int
        """
        A positive integer representing the amount to subtract from an invoice total.
        """

    class DeleteParams(RequestOptions):
        pass

    class ListParams(RequestOptions):
        created: NotRequired["Coupon.ListParamsCreated|int"]
        """
        A filter on the list, based on the object `created` field. The value can be a string with an integer Unix timestamp, or it can be a dictionary with a number of different query options.
        """
        ending_before: NotRequired[str]
        """
        A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
        """
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """
        limit: NotRequired[int]
        """
        A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
        """
        starting_after: NotRequired[str]
        """
        A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
        """

    class ListParamsCreated(TypedDict):
        gt: NotRequired[int]
        """
        Minimum value to filter by (exclusive)
        """
        gte: NotRequired[int]
        """
        Minimum value to filter by (inclusive)
        """
        lt: NotRequired[int]
        """
        Maximum value to filter by (exclusive)
        """
        lte: NotRequired[int]
        """
        Maximum value to filter by (inclusive)
        """

    class ModifyParams(RequestOptions):
        currency_options: NotRequired[
            Dict[str, "Coupon.ModifyParamsCurrencyOptions"]
        ]
        """
        Coupons defined in each available currency option (only supported if the coupon is amount-based). Each key must be a three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html) and a [supported currency](https://stripe.com/docs/currencies).
        """
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """
        metadata: NotRequired["Literal['']|Dict[str, str]"]
        """
        Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
        """
        name: NotRequired[str]
        """
        Name of the coupon displayed to customers on, for instance invoices, or receipts. By default the `id` is shown if `name` is not set.
        """

    class ModifyParamsCurrencyOptions(TypedDict):
        amount_off: int
        """
        A positive integer representing the amount to subtract from an invoice total.
        """

    class RetrieveParams(RequestOptions):
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """

    amount_off: Optional[int]
    """
    Amount (in the `currency` specified) that will be taken off the subtotal of any invoices for this customer.
    """
    applies_to: Optional[AppliesTo]
    created: int
    """
    Time at which the object was created. Measured in seconds since the Unix epoch.
    """
    currency: Optional[str]
    """
    If `amount_off` has been set, the three-letter [ISO code for the currency](https://stripe.com/docs/currencies) of the amount to take off.
    """
    currency_options: Optional[Dict[str, CurrencyOptions]]
    """
    Coupons defined in each available currency option. Each key must be a three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html) and a [supported currency](https://stripe.com/docs/currencies).
    """
    duration: Literal["forever", "once", "repeating"]
    """
    One of `forever`, `once`, and `repeating`. Describes how long a customer who applies this coupon will get the discount.
    """
    duration_in_months: Optional[int]
    """
    If `duration` is `repeating`, the number of months the coupon applies. Null if coupon `duration` is `forever` or `once`.
    """
    id: str
    """
    Unique identifier for the object.
    """
    livemode: bool
    """
    Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
    """
    max_redemptions: Optional[int]
    """
    Maximum number of times this coupon can be redeemed, in total, across all customers, before it is no longer valid.
    """
    metadata: Optional[Dict[str, str]]
    """
    Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format.
    """
    name: Optional[str]
    """
    Name of the coupon displayed to customers on for instance invoices or receipts.
    """
    object: Literal["coupon"]
    """
    String representing the object's type. Objects of the same type share the same value.
    """
    percent_off: Optional[float]
    """
    Percent that will be taken off the subtotal of any invoices for this customer for the duration of the coupon. For example, a coupon with percent_off of 50 will make a $ (or local equivalent)100 invoice $ (or local equivalent)50 instead.
    """
    redeem_by: Optional[int]
    """
    Date after which the coupon can no longer be redeemed.
    """
    times_redeemed: int
    """
    Number of times this coupon has been applied to a customer.
    """
    valid: bool
    """
    Taking account of the above properties, whether this coupon can still be applied to a customer.
    """
    deleted: Optional[Literal[True]]
    """
    Always true for a deleted object
    """

    @classmethod
    def create(cls, **params: Unpack["Coupon.CreateParams"]) -> "Coupon":
        """
        You can create coupons easily via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. Coupon creation is also accessible via the API if you need to create coupons on the fly.

        A coupon has either a percent_off or an amount_off and currency. If you set an amount_off, that amount will be subtracted from any invoice's subtotal. For example, an invoice with a subtotal of 100 will have a final total of 0 if a coupon with an amount_off of 200 is applied to it and an invoice with a subtotal of 300 will have a final total of 100 if a coupon with an amount_off of 200 is applied to it.
        """
        return cast(
            "Coupon",
            cls._static_request(
                "post",
                cls.class_url(),
                params=params,
            ),
        )

    @classmethod
    async def create_async(
        cls, **params: Unpack["Coupon.CreateParams"]
    ) -> "Coupon":
        """
        You can create coupons easily via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. Coupon creation is also accessible via the API if you need to create coupons on the fly.

        A coupon has either a percent_off or an amount_off and currency. If you set an amount_off, that amount will be subtracted from any invoice's subtotal. For example, an invoice with a subtotal of 100 will have a final total of 0 if a coupon with an amount_off of 200 is applied to it and an invoice with a subtotal of 300 will have a final total of 100 if a coupon with an amount_off of 200 is applied to it.
        """
        return cast(
            "Coupon",
            await cls._static_request_async(
                "post",
                cls.class_url(),
                params=params,
            ),
        )

    @classmethod
    def _cls_delete(
        cls, sid: str, **params: Unpack["Coupon.DeleteParams"]
    ) -> "Coupon":
        """
        You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
        """
        url = "%s/%s" % (cls.class_url(), sanitize_id(sid))
        return cast(
            "Coupon",
            cls._static_request(
                "delete",
                url,
                params=params,
            ),
        )

    @overload
    @staticmethod
    def delete(sid: str, **params: Unpack["Coupon.DeleteParams"]) -> "Coupon":
        """
        You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
        """
        ...

    @overload
    def delete(self, **params: Unpack["Coupon.DeleteParams"]) -> "Coupon":
        """
        You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
        """
        ...

    @class_method_variant("_cls_delete")
    def delete(  # pyright: ignore[reportGeneralTypeIssues]
        self, **params: Unpack["Coupon.DeleteParams"]
    ) -> "Coupon":
        """
        You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
        """
        return self._request_and_refresh(
            "delete",
            self.instance_url(),
            params=params,
        )

    @classmethod
    async def _cls_delete_async(
        cls, sid: str, **params: Unpack["Coupon.DeleteParams"]
    ) -> "Coupon":
        """
        You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
        """
        url = "%s/%s" % (cls.class_url(), sanitize_id(sid))
        return cast(
            "Coupon",
            await cls._static_request_async(
                "delete",
                url,
                params=params,
            ),
        )

    @overload
    @staticmethod
    async def delete_async(
        sid: str, **params: Unpack["Coupon.DeleteParams"]
    ) -> "Coupon":
        """
        You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
        """
        ...

    @overload
    async def delete_async(
        self, **params: Unpack["Coupon.DeleteParams"]
    ) -> "Coupon":
        """
        You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
        """
        ...

    @class_method_variant("_cls_delete_async")
    async def delete_async(  # pyright: ignore[reportGeneralTypeIssues]
        self, **params: Unpack["Coupon.DeleteParams"]
    ) -> "Coupon":
        """
        You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
        """
        return await self._request_and_refresh_async(
            "delete",
            self.instance_url(),
            params=params,
        )

    @classmethod
    def list(
        cls, **params: Unpack["Coupon.ListParams"]
    ) -> ListObject["Coupon"]:
        """
        Returns a list of your coupons.
        """
        result = cls._static_request(
            "get",
            cls.class_url(),
            params=params,
        )
        if not isinstance(result, ListObject):
            raise TypeError(
                "Expected list object from API, got %s"
                % (type(result).__name__)
            )

        return result

    @classmethod
    async def list_async(
        cls, **params: Unpack["Coupon.ListParams"]
    ) -> ListObject["Coupon"]:
        """
        Returns a list of your coupons.
        """
        result = await cls._static_request_async(
            "get",
            cls.class_url(),
            params=params,
        )
        if not isinstance(result, ListObject):
            raise TypeError(
                "Expected list object from API, got %s"
                % (type(result).__name__)
            )

        return result

    @classmethod
    def modify(
        cls, id: str, **params: Unpack["Coupon.ModifyParams"]
    ) -> "Coupon":
        """
        Updates the metadata of a coupon. Other coupon details (currency, duration, amount_off) are, by design, not editable.
        """
        url = "%s/%s" % (cls.class_url(), sanitize_id(id))
        return cast(
            "Coupon",
            cls._static_request(
                "post",
                url,
                params=params,
            ),
        )

    @classmethod
    async def modify_async(
        cls, id: str, **params: Unpack["Coupon.ModifyParams"]
    ) -> "Coupon":
        """
        Updates the metadata of a coupon. Other coupon details (currency, duration, amount_off) are, by design, not editable.
        """
        url = "%s/%s" % (cls.class_url(), sanitize_id(id))
        return cast(
            "Coupon",
            await cls._static_request_async(
                "post",
                url,
                params=params,
            ),
        )

    @classmethod
    def retrieve(
        cls, id: str, **params: Unpack["Coupon.RetrieveParams"]
    ) -> "Coupon":
        """
        Retrieves the coupon with the given ID.
        """
        instance = cls(id, **params)
        instance.refresh()
        return instance

    @classmethod
    async def retrieve_async(
        cls, id: str, **params: Unpack["Coupon.RetrieveParams"]
    ) -> "Coupon":
        """
        Retrieves the coupon with the given ID.
        """
        instance = cls(id, **params)
        await instance.refresh_async()
        return instance

    _inner_class_types = {
        "applies_to": AppliesTo,
        "currency_options": CurrencyOptions,
    }

1	# -- coding: utf-8 --
2	# File generated from our OpenAPI spec
3	from stripe._createable_api_resource import CreateableAPIResource	1✔
4	from stripe._deletable_api_resource import DeletableAPIResource	1✔
5	from stripe._list_object import ListObject	1✔
6	from stripe._listable_api_resource import ListableAPIResource	1✔
7	from stripe._request_options import RequestOptions	1✔
8	from stripe._stripe_object import StripeObject	1✔
9	from stripe._updateable_api_resource import UpdateableAPIResource	1✔
10	from stripe._util import class_method_variant, sanitize_id	1✔
11	from typing import ClassVar, Dict, List, Optional, cast, overload	1✔
12	from typing_extensions import Literal, NotRequired, TypedDict, Unpack	1✔
13
14
15	class Coupon(	1✔
16	CreateableAPIResource["Coupon"],
17	DeletableAPIResource["Coupon"],
18	ListableAPIResource["Coupon"],
19	UpdateableAPIResource["Coupon"],
20	):
21	"""
22	A coupon contains information about a percent-off or amount-off discount you
23	might want to apply to a customer. Coupons may be applied to [subscriptions](https://stripe.com/docs/api#subscriptions), [invoices](https://stripe.com/docs/api#invoices),
24	[checkout sessions](https://stripe.com/docs/api/checkout/sessions), [quotes](https://stripe.com/docs/api#quotes), and more. Coupons do not work with conventional one-off [charges](https://stripe.com/docs/api#create_charge) or [payment intents](https://stripe.com/docs/api/payment_intents).
25	"""
26
27	OBJECT_NAME: ClassVar[Literal["coupon"]] = "coupon"	1✔
28
29	class AppliesTo(StripeObject):	1✔
30	products: List[str]	1✔
31	"""	1✔
32	A list of product IDs this coupon applies to
33	"""
34
35	class CurrencyOptions(StripeObject):	1✔
36	amount_off: int	1✔
37	"""	1✔
38	Amount (in the `currency` specified) that will be taken off the subtotal of any invoices for this customer.
39	"""
40
41	class CreateParams(RequestOptions):	1✔
42	amount_off: NotRequired[int]	1✔
43	"""	1✔
44	A positive integer representing the amount to subtract from an invoice total (required if `percent_off` is not passed).
45	"""
46	applies_to: NotRequired["Coupon.CreateParamsAppliesTo"]	1✔
47	"""	1✔
48	A hash containing directions for what this Coupon will apply discounts to.
49	"""
50	currency: NotRequired[str]	1✔
51	"""	1✔
52	Three-letter [ISO code for the currency](https://stripe.com/docs/currencies) of the `amount_off` parameter (required if `amount_off` is passed).
53	"""
54	currency_options: NotRequired[	1✔
55	Dict[str, "Coupon.CreateParamsCurrencyOptions"]
56	]
57	"""	1✔
58	Coupons defined in each available currency option (only supported if `amount_off` is passed). Each key must be a three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html) and a [supported currency](https://stripe.com/docs/currencies).
59	"""
60	duration: NotRequired[Literal["forever", "once", "repeating"]]	1✔
61	"""	1✔
62	Specifies how long the discount will be in effect if used on a subscription. Defaults to `once`.
63	"""
64	duration_in_months: NotRequired[int]	1✔
65	"""	1✔
66	Required only if `duration` is `repeating`, in which case it must be a positive integer that specifies the number of months the discount will be in effect.
67	"""
68	expand: NotRequired[List[str]]	1✔
69	"""	1✔
70	Specifies which fields in the response should be expanded.
71	"""
72	id: NotRequired[str]	1✔
73	"""	1✔
74	Unique string of your choice that will be used to identify this coupon when applying it to a customer. If you don't want to specify a particular code, you can leave the ID blank and we'll generate a random code for you.
75	"""
76	max_redemptions: NotRequired[int]	1✔
77	"""	1✔
78	A positive integer specifying the number of times the coupon can be redeemed before it's no longer valid. For example, you might have a 50% off coupon that the first 20 readers of your blog can use.
79	"""
80	metadata: NotRequired["Literal['']\|Dict[str, str]"]	1✔
81	"""	1✔
82	Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
83	"""
84	name: NotRequired[str]	1✔
85	"""	1✔
86	Name of the coupon displayed to customers on, for instance invoices, or receipts. By default the `id` is shown if `name` is not set.
87	"""
88	percent_off: NotRequired[float]	1✔
89	"""	1✔
90	A positive float larger than 0, and smaller or equal to 100, that represents the discount the coupon will apply (required if `amount_off` is not passed).
91	"""
92	redeem_by: NotRequired[int]	1✔
93	"""	1✔
94	Unix timestamp specifying the last time at which the coupon can be redeemed. After the redeem_by date, the coupon can no longer be applied to new customers.
95	"""
96
97	class CreateParamsAppliesTo(TypedDict):	1✔
98	products: NotRequired[List[str]]	1✔
99	"""	1✔
100	An array of Product IDs that this Coupon will apply to.
101	"""
102
103	class CreateParamsCurrencyOptions(TypedDict):	1✔
104	amount_off: int	1✔
105	"""	1✔
106	A positive integer representing the amount to subtract from an invoice total.
107	"""
108
109	class DeleteParams(RequestOptions):	1✔
110	pass	1✔
111
112	class ListParams(RequestOptions):	1✔
113	created: NotRequired["Coupon.ListParamsCreated\|int"]	1✔
114	"""	1✔
115	A filter on the list, based on the object `created` field. The value can be a string with an integer Unix timestamp, or it can be a dictionary with a number of different query options.
116	"""
117	ending_before: NotRequired[str]	1✔
118	"""	1✔
119	A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
120	"""
121	expand: NotRequired[List[str]]	1✔
122	"""	1✔
123	Specifies which fields in the response should be expanded.
124	"""
125	limit: NotRequired[int]	1✔
126	"""	1✔
127	A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
128	"""
129	starting_after: NotRequired[str]	1✔
130	"""	1✔
131	A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
132	"""
133
134	class ListParamsCreated(TypedDict):	1✔
135	gt: NotRequired[int]	1✔
136	"""	1✔
137	Minimum value to filter by (exclusive)
138	"""
139	gte: NotRequired[int]	1✔
140	"""	1✔
141	Minimum value to filter by (inclusive)
142	"""
143	lt: NotRequired[int]	1✔
144	"""	1✔
145	Maximum value to filter by (exclusive)
146	"""
147	lte: NotRequired[int]	1✔
148	"""	1✔
149	Maximum value to filter by (inclusive)
150	"""
151
152	class ModifyParams(RequestOptions):	1✔
153	currency_options: NotRequired[	1✔
154	Dict[str, "Coupon.ModifyParamsCurrencyOptions"]
155	]
156	"""	1✔
157	Coupons defined in each available currency option (only supported if the coupon is amount-based). Each key must be a three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html) and a [supported currency](https://stripe.com/docs/currencies).
158	"""
159	expand: NotRequired[List[str]]	1✔
160	"""	1✔
161	Specifies which fields in the response should be expanded.
162	"""
163	metadata: NotRequired["Literal['']\|Dict[str, str]"]	1✔
164	"""	1✔
165	Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
166	"""
167	name: NotRequired[str]	1✔
168	"""	1✔
169	Name of the coupon displayed to customers on, for instance invoices, or receipts. By default the `id` is shown if `name` is not set.
170	"""
171
172	class ModifyParamsCurrencyOptions(TypedDict):	1✔
173	amount_off: int	1✔
174	"""	1✔
175	A positive integer representing the amount to subtract from an invoice total.
176	"""
177
178	class RetrieveParams(RequestOptions):	1✔
179	expand: NotRequired[List[str]]	1✔
180	"""	1✔
181	Specifies which fields in the response should be expanded.
182	"""
183
184	amount_off: Optional[int]	1✔
185	"""	1✔
186	Amount (in the `currency` specified) that will be taken off the subtotal of any invoices for this customer.
187	"""
188	applies_to: Optional[AppliesTo]	1✔
189	created: int	1✔
190	"""	1✔
191	Time at which the object was created. Measured in seconds since the Unix epoch.
192	"""
193	currency: Optional[str]	1✔
194	"""	1✔
195	If `amount_off` has been set, the three-letter [ISO code for the currency](https://stripe.com/docs/currencies) of the amount to take off.
196	"""
197	currency_options: Optional[Dict[str, CurrencyOptions]]	1✔
198	"""	1✔
199	Coupons defined in each available currency option. Each key must be a three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html) and a [supported currency](https://stripe.com/docs/currencies).
200	"""
201	duration: Literal["forever", "once", "repeating"]	1✔
202	"""	1✔
203	One of `forever`, `once`, and `repeating`. Describes how long a customer who applies this coupon will get the discount.
204	"""
205	duration_in_months: Optional[int]	1✔
206	"""	1✔
207	If `duration` is `repeating`, the number of months the coupon applies. Null if coupon `duration` is `forever` or `once`.
208	"""
209	id: str	1✔
210	"""	1✔
211	Unique identifier for the object.
212	"""
213	livemode: bool	1✔
214	"""	1✔
215	Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
216	"""
217	max_redemptions: Optional[int]	1✔
218	"""	1✔
219	Maximum number of times this coupon can be redeemed, in total, across all customers, before it is no longer valid.
220	"""
221	metadata: Optional[Dict[str, str]]	1✔
222	"""	1✔
223	Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format.
224	"""
225	name: Optional[str]	1✔
226	"""	1✔
227	Name of the coupon displayed to customers on for instance invoices or receipts.
228	"""
229	object: Literal["coupon"]	1✔
230	"""	1✔
231	String representing the object's type. Objects of the same type share the same value.
232	"""
233	percent_off: Optional[float]	1✔
234	"""	1✔
235	Percent that will be taken off the subtotal of any invoices for this customer for the duration of the coupon. For example, a coupon with percent_off of 50 will make a $ (or local equivalent)100 invoice $ (or local equivalent)50 instead.
236	"""
237	redeem_by: Optional[int]	1✔
238	"""	1✔
239	Date after which the coupon can no longer be redeemed.
240	"""
241	times_redeemed: int	1✔
242	"""	1✔
243	Number of times this coupon has been applied to a customer.
244	"""
245	valid: bool	1✔
246	"""	1✔
247	Taking account of the above properties, whether this coupon can still be applied to a customer.
248	"""
249	deleted: Optional[Literal[True]]	1✔
250	"""	1✔
251	Always true for a deleted object
252	"""
253
254	@classmethod	1✔
255	def create(cls, **params: Unpack["Coupon.CreateParams"]) -> "Coupon":	1✔
256	"""
257	You can create coupons easily via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. Coupon creation is also accessible via the API if you need to create coupons on the fly.
258
259	A coupon has either a percent_off or an amount_off and currency. If you set an amount_off, that amount will be subtracted from any invoice's subtotal. For example, an invoice with a subtotal of 100 will have a final total of 0 if a coupon with an amount_off of 200 is applied to it and an invoice with a subtotal of 300 will have a final total of 100 if a coupon with an amount_off of 200 is applied to it.
260	"""
261	return cast(	1✔
262	"Coupon",
263	cls._static_request(
264	"post",
265	cls.class_url(),
266	params=params,
267	),
268	)
269
270	@classmethod	1✔
271	async def create_async(	1✔
272	cls, **params: Unpack["Coupon.CreateParams"]
273	) -> "Coupon":
274	"""
275	You can create coupons easily via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. Coupon creation is also accessible via the API if you need to create coupons on the fly.
276
277	A coupon has either a percent_off or an amount_off and currency. If you set an amount_off, that amount will be subtracted from any invoice's subtotal. For example, an invoice with a subtotal of 100 will have a final total of 0 if a coupon with an amount_off of 200 is applied to it and an invoice with a subtotal of 300 will have a final total of 100 if a coupon with an amount_off of 200 is applied to it.
278	"""
279	return cast(	1✔
280	"Coupon",
281	await cls._static_request_async(
282	"post",
283	cls.class_url(),
284	params=params,
285	),
286	)
287
288	@classmethod	1✔
289	def _cls_delete(	1✔
290	cls, sid: str, **params: Unpack["Coupon.DeleteParams"]
291	) -> "Coupon":
292	"""
293	You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
294	"""
295	url = "%s/%s" % (cls.class_url(), sanitize_id(sid))	1✔
296	return cast(	1✔
297	"Coupon",
298	cls._static_request(
299	"delete",
300	url,
301	params=params,
302	),
303	)
304
305	@overload	1✔
306	@staticmethod	1✔
307	def delete(sid: str, **params: Unpack["Coupon.DeleteParams"]) -> "Coupon":	1✔
308	"""
309	You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
310	"""
311	...	×
312
313	@overload	1✔
314	def delete(self, **params: Unpack["Coupon.DeleteParams"]) -> "Coupon":	1✔
315	"""
316	You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
317	"""
318	...	×
319
320	@class_method_variant("_cls_delete")	1✔
321	def delete( # pyright: ignore[reportGeneralTypeIssues]	1✔
322	self, **params: Unpack["Coupon.DeleteParams"]
323	) -> "Coupon":
324	"""
325	You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
326	"""
327	return self._request_and_refresh(	1✔
328	"delete",
329	self.instance_url(),
330	params=params,
331	)
332
333	@classmethod	1✔
334	async def _cls_delete_async(	1✔
335	cls, sid: str, **params: Unpack["Coupon.DeleteParams"]
336	) -> "Coupon":
337	"""
338	You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
339	"""
340	url = "%s/%s" % (cls.class_url(), sanitize_id(sid))	1✔
341	return cast(	1✔
342	"Coupon",
343	await cls._static_request_async(
344	"delete",
345	url,
346	params=params,
347	),
348	)
349
350	@overload	1✔
351	@staticmethod	1✔
352	async def delete_async(	1✔
353	sid: str, **params: Unpack["Coupon.DeleteParams"]
354	) -> "Coupon":
355	"""
356	You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
357	"""
358	...	×
359
360	@overload	1✔
361	async def delete_async(	1✔
362	self, **params: Unpack["Coupon.DeleteParams"]
363	) -> "Coupon":
364	"""
365	You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
366	"""
367	...	×
368
369	@class_method_variant("_cls_delete_async")	1✔
370	async def delete_async( # pyright: ignore[reportGeneralTypeIssues]	1✔
371	self, **params: Unpack["Coupon.DeleteParams"]
372	) -> "Coupon":
373	"""
374	You can delete coupons via the [coupon management](https://dashboard.stripe.com/coupons) page of the Stripe dashboard. However, deleting a coupon does not affect any customers who have already applied the coupon; it means that new customers can't redeem the coupon. You can also delete coupons via the API.
375	"""
376	return await self._request_and_refresh_async(	×
377	"delete",
378	self.instance_url(),
379	params=params,
380	)
381
382	@classmethod	1✔
383	def list(	1✔
384	cls, **params: Unpack["Coupon.ListParams"]
385	) -> ListObject["Coupon"]:
386	"""
387	Returns a list of your coupons.
388	"""
389	result = cls._static_request(	1✔
390	"get",
391	cls.class_url(),
392	params=params,
393	)
394	if not isinstance(result, ListObject):	1!
UNCOV 395	raise TypeError(	×
396	"Expected list object from API, got %s"
397	% (type(result).__name__)
398	)
399
400	return result	1✔
401
402	@classmethod	1✔
403	async def list_async(	1✔
404	cls, **params: Unpack["Coupon.ListParams"]
405	) -> ListObject["Coupon"]:
406	"""
407	Returns a list of your coupons.
408	"""
409	result = await cls._static_request_async(	1✔
410	"get",
411	cls.class_url(),
412	params=params,
413	)
414	if not isinstance(result, ListObject):	1!
UNCOV 415	raise TypeError(	×
416	"Expected list object from API, got %s"
417	% (type(result).__name__)
418	)
419
420	return result	1✔
421
422	@classmethod	1✔
423	def modify(	1✔
424	cls, id: str, **params: Unpack["Coupon.ModifyParams"]
425	) -> "Coupon":
426	"""
427	Updates the metadata of a coupon. Other coupon details (currency, duration, amount_off) are, by design, not editable.
428	"""
429	url = "%s/%s" % (cls.class_url(), sanitize_id(id))	1✔
430	return cast(	1✔
431	"Coupon",
432	cls._static_request(
433	"post",
434	url,
435	params=params,
436	),
437	)
438
439	@classmethod	1✔
440	async def modify_async(	1✔
441	cls, id: str, **params: Unpack["Coupon.ModifyParams"]
442	) -> "Coupon":
443	"""
444	Updates the metadata of a coupon. Other coupon details (currency, duration, amount_off) are, by design, not editable.
445	"""
446	url = "%s/%s" % (cls.class_url(), sanitize_id(id))	1✔
447	return cast(	1✔
448	"Coupon",
449	await cls._static_request_async(
450	"post",
451	url,
452	params=params,
453	),
454	)
455
456	@classmethod	1✔
457	def retrieve(	1✔
458	cls, id: str, **params: Unpack["Coupon.RetrieveParams"]
459	) -> "Coupon":
460	"""
461	Retrieves the coupon with the given ID.
462	"""
463	instance = cls(id, **params)	1✔
464	instance.refresh()	1✔
465	return instance	1✔
466
467	@classmethod	1✔
468	async def retrieve_async(	1✔
469	cls, id: str, **params: Unpack["Coupon.RetrieveParams"]
470	) -> "Coupon":
471	"""
472	Retrieves the coupon with the given ID.
473	"""
474	instance = cls(id, **params)	1✔
475	await instance.refresh_async()	1✔
476	return instance	1✔
477
478	_inner_class_types = {	1✔
479	"applies_to": AppliesTo,
480	"currency_options": CurrencyOptions,
481	}

stripe / stripe-python / 9113607451

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous