def __str__(self):
    return self.description

def api_retrieve(self, *args, **kwargs):
    if "-il_" in self.id:
        warnings.warn(
            f"Attempting to retrieve InvoiceItem with id={self.id!r}"
            " will most likely fail. "
            "Run manage.py djstripe_update_invoiceitem_ids if this is a problem."
        )

    return super().api_retrieve(*args, **kwargs)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def get_stripe_dashboard_url(self):
    return self.invoice.get_stripe_dashboard_url()

@classmethod
def is_valid_object(cls, data):
    return "object" in data and data["object"] in ("invoiceitem", "line_item")

def __str__(self):

    subscriptions_lst = self.customer._get_valid_subscriptions()
    products_lst = [
        subscription.plan.product.name
        for subscription in subscriptions_lst
        if subscription and subscription.plan
    ]

    return f"{self.customer} on {' and '.join(products_lst)}"

def cancel(self, at_period_end=djstripe_settings.CANCELLATION_AT_PERIOD_END):
    """
    Cancels this subscription. If you set the at_period_end parameter to true,
    the subscription will remain active until the end of the period, at which point
    it will be canceled and not renewed. By default, the subscription is terminated
    immediately. In either case, the customer will not be charged again for
    the subscription. Note, however, that any pending invoice items that you've
    created will still be charged for at the end of the period unless manually
    deleted. If you've set the subscription to cancel at period end,
    any pending prorations will also be left in place and collected at the end of
    the period, but if the subscription is set to cancel immediately,
    pending prorations will be removed.

    By default, all unpaid invoices for the customer will be closed upon
    subscription cancellation. We do this in order to prevent unexpected payment
    retries once the customer has canceled a subscription. However, you can
    reopen the invoices manually after subscription cancellation to have us proceed
    with automatic retries, or you could even re-attempt payment yourself on all
    unpaid invoices before allowing the customer to cancel the
    subscription at all.

    :param at_period_end: A flag that if set to true will delay the cancellation \
        of the subscription until the end of the current period. Default is False.
    :type at_period_end: boolean

    .. important:: If a subscription is canceled during a trial period, \
    the ``at_period_end`` flag will be overridden to False so that the trial ends \
    immediately and the customer's card isn't charged.
    """

    # If plan has trial days and customer cancels before
    # trial period ends, then end subscription now,
    # i.e. at_period_end=False
    if self.trial_end and self.trial_end > timezone.now():
        at_period_end = False

    if at_period_end:
        stripe_subscription = self._api_update(cancel_at_period_end=True)
    else:
        try:
            stripe_subscription = self._api_delete()
        except InvalidRequestError as exc:
            if "No such subscription:" in str(exc):
                # cancel() works by deleting the subscription. The object still
                # exists in Stripe however, and can still be retrieved.
                # If the subscription was already canceled (status=canceled),
                # that api_retrieve() call will fail with "No such subscription".
                # However, this may also happen if the subscription legitimately
                # does not exist, in which case the following line will re-raise.
                stripe_subscription = self.api_retrieve()
            else:
                raise

    return Subscription.sync_from_stripe_data(stripe_subscription)

def extend(self, delta):
    """
    Extends this subscription by the provided delta.

    :param delta: The timedelta by which to extend this subscription.
    :type delta: timedelta
    """

    if delta.total_seconds() < 0:
        raise ValueError("delta must be a positive timedelta.")

    if self.trial_end is not None and self.trial_end > timezone.now():
        period_end = self.trial_end
    else:
        period_end = self.current_period_end

    period_end += delta

    return self.update(proration_behavior="none", trial_end=period_end)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def is_period_current(self):
    """
    Returns True if this subscription's period is current, false otherwise.
    """

    return self.current_period_end > timezone.now() or (
        self.trial_end and self.trial_end > timezone.now()
    )

def is_status_current(self):
    """
    Returns True if this subscription's status is current (active or trialing),
    false otherwise.
    """

    return self.status in ["trialing", "active"]

def is_status_temporarily_current(self):
    """
    A status is temporarily current when the subscription is canceled with the
    ``at_period_end`` flag.
    The subscription is still active, but is technically canceled and we're just
    waiting for it to run out.

    You could use this method to give customers limited service after they've
    canceled. For example, a video on demand service could only allow customers
    to download their libraries and do nothing else when their
    subscription is temporarily current.
    """

    return (
        self.canceled_at
        and self.cancel_at_period_end
        and timezone.now() < self.current_period_end
    )

def is_valid(self):
    """
    Returns True if this subscription's status and period are current,
    false otherwise.
    """

    if not self.is_status_current():
        return False

    if not self.is_period_current():
        return False

    return True

def reactivate(self):
    """
    Reactivates this subscription.

    If a customer's subscription is canceled with ``at_period_end`` set to True and
    it has not yet reached the end of the billing period, it can be reactivated.
    Subscriptions canceled immediately cannot be reactivated.
    (Source: https://stripe.com/docs/billing/subscriptions/cancel)

    .. warning:: Reactivating a fully canceled Subscription will fail silently. \
    Be sure to check the returned Subscription's status.
    """
    stripe_subscription = self.api_retrieve()
    stripe_subscription.plan = self.plan.id
    stripe_subscription.cancel_at_period_end = False

    return Subscription.sync_from_stripe_data(stripe_subscription.save())

def update(
    self,
    plan: Union[StripeModel, str] = None,
    prorate: bool = None,
    **kwargs,
):
    """
    See `Customer.subscribe() <#djstripe.models.Customer.subscribe>`__

    :param plan: The plan to which to subscribe the customer.
    :type plan: Plan or string (plan ID)

    .. note:: The default value for ``prorate`` is the DJSTRIPE_PRORATION_POLICY \
        setting.

    .. important:: Updating a subscription by changing the plan or quantity \
        creates a new ``Subscription`` in \
        Stripe (and dj-stripe).
    """

    # Convert Plan to id
    if plan is not None and isinstance(plan, StripeModel):
        plan = plan.id

    if "proration_behavior" not in kwargs:
        if prorate is not None:
            warnings.warn(
                "The `prorate` parameter to Subscription.update() is deprecated "
                "by Stripe. Use `proration_behavior` instead.\n"
                "Read more: "
                "https://stripe.com/docs/billing/subscriptions/prorations"
            )
        else:
            prorate = djstripe_settings.PRORATION_POLICY

        if prorate:
            kwargs.setdefault("proration_behavior", "create_prorations")
        else:
            kwargs.setdefault("proration_behavior", "none")

    stripe_subscription = self._api_update(plan=plan, **kwargs)

    return Subscription.sync_from_stripe_data(stripe_subscription)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)

def __str__(self):
    return f"{enums.TaxIdType.humanize(self.type)} {self.value} ({self.verification.get('status')})"

@classmethod
def api_list(cls, api_key=djstripe_settings.STRIPE_SECRET_KEY, **kwargs):
    """
    Call the stripe API's list operation for this model.
    :param api_key: The api key to use for this request. \
        Defaults to djstripe_settings.STRIPE_SECRET_KEY.
    :type api_key: string
    See Stripe documentation for accepted kwargs for each object.
    :returns: an iterator over all items in the query
    """
    return stripe.Customer.list_tax_ids(
        api_key=api_key, **kwargs
    ).auto_paging_iter()

def api_retrieve(self, api_key=None, stripe_account=None):
    """
    Call the stripe API's retrieve operation for this model.
    :param api_key: The api key to use for this request. \
        Defaults to djstripe_settings.STRIPE_SECRET_KEY.
    :type api_key: string
    :param stripe_account: The optional connected account \
        for which this request is being made.
    :type stripe_account: string
    """
    nested_id = self.id
    id = self.customer.id

    # Prefer passed in stripe_account if set.
    if not stripe_account:
        stripe_account = self._get_stripe_account_id(api_key)

    return stripe.Customer.retrieve_tax_id(
        id=id,
        nested_id=nested_id,
        api_key=api_key or self.default_api_key,
        expand=self.expand_fields,
        stripe_account=stripe_account,
    )

def _method(cls_or_self, /, *args, **keywords):
    keywords = {**self.keywords, **keywords}
    return self.func(cls_or_self, *self.args, *args, **keywords)