diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 7cfa47b4..fe941d15 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.78.1" + ".": "0.79.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index c7af722a..77de7290 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1 +1 @@ -configured_endpoints: 148 +configured_endpoints: 150 diff --git a/CHANGELOG.md b/CHANGELOG.md index 27b5c386..eb9fa743 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.79.0 (2024-11-14) + +Full Changelog: [v0.78.1...v0.79.0](https://github.com/lithic-com/lithic-python/compare/v0.78.1...v0.79.0) + +### Features + +* **api:** adds PrimeRates API ([#628](https://github.com/lithic-com/lithic-python/issues/628)) ([f0a2272](https://github.com/lithic-com/lithic-python/commit/f0a22728c090d593b483c562c61adaa71cd0221e)) + ## 0.78.1 (2024-11-12) Full Changelog: [v0.78.0...v0.78.1](https://github.com/lithic-com/lithic-python/compare/v0.78.0...v0.78.1) diff --git a/api.md b/api.md index e4a4b2e3..1305bc6d 100644 --- a/api.md +++ b/api.md @@ -628,7 +628,20 @@ from lithic.types.credit_products import ExtendedCredit Methods: -- client.credit_products.extended_credit.retrieve(credit_product_id) -> ExtendedCredit +- client.credit_products.extended_credit.retrieve(credit_product_token) -> ExtendedCredit + +## PrimeRates + +Types: + +```python +from lithic.types.credit_products import PrimeRateRetrieveResponse +``` + +Methods: + +- client.credit_products.prime_rates.create(credit_product_token, \*\*params) -> None +- client.credit_products.prime_rates.retrieve(credit_product_token, \*\*params) -> PrimeRateRetrieveResponse # ExternalPayments diff --git a/pyproject.toml b/pyproject.toml index 1c93847e..01ff401c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "lithic" -version = "0.78.1" +version = "0.79.0" description = "The official Python library for the lithic API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/lithic/_version.py b/src/lithic/_version.py index 7691814e..d3fa5371 100644 --- a/src/lithic/_version.py +++ b/src/lithic/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "lithic" -__version__ = "0.78.1" # x-release-please-version +__version__ = "0.79.0" # x-release-please-version diff --git a/src/lithic/resources/credit_products/__init__.py b/src/lithic/resources/credit_products/__init__.py index 960fc9bf..f7b13736 100644 --- a/src/lithic/resources/credit_products/__init__.py +++ b/src/lithic/resources/credit_products/__init__.py @@ -1,5 +1,13 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. +from .prime_rates import ( + PrimeRates, + AsyncPrimeRates, + PrimeRatesWithRawResponse, + AsyncPrimeRatesWithRawResponse, + PrimeRatesWithStreamingResponse, + AsyncPrimeRatesWithStreamingResponse, +) from .credit_products import ( CreditProducts, AsyncCreditProducts, @@ -24,6 +32,12 @@ "AsyncExtendedCreditResourceWithRawResponse", "ExtendedCreditResourceWithStreamingResponse", "AsyncExtendedCreditResourceWithStreamingResponse", + "PrimeRates", + "AsyncPrimeRates", + "PrimeRatesWithRawResponse", + "AsyncPrimeRatesWithRawResponse", + "PrimeRatesWithStreamingResponse", + "AsyncPrimeRatesWithStreamingResponse", "CreditProducts", "AsyncCreditProducts", "CreditProductsWithRawResponse", diff --git a/src/lithic/resources/credit_products/credit_products.py b/src/lithic/resources/credit_products/credit_products.py index f57a48aa..81866cda 100644 --- a/src/lithic/resources/credit_products/credit_products.py +++ b/src/lithic/resources/credit_products/credit_products.py @@ -4,6 +4,14 @@ from ..._compat import cached_property from ..._resource import SyncAPIResource, AsyncAPIResource +from .prime_rates import ( + PrimeRates, + AsyncPrimeRates, + PrimeRatesWithRawResponse, + AsyncPrimeRatesWithRawResponse, + PrimeRatesWithStreamingResponse, + AsyncPrimeRatesWithStreamingResponse, +) from .extended_credit import ( ExtendedCreditResource, AsyncExtendedCreditResource, @@ -21,6 +29,10 @@ class CreditProducts(SyncAPIResource): def extended_credit(self) -> ExtendedCreditResource: return ExtendedCreditResource(self._client) + @cached_property + def prime_rates(self) -> PrimeRates: + return PrimeRates(self._client) + @cached_property def with_raw_response(self) -> CreditProductsWithRawResponse: """ @@ -46,6 +58,10 @@ class AsyncCreditProducts(AsyncAPIResource): def extended_credit(self) -> AsyncExtendedCreditResource: return AsyncExtendedCreditResource(self._client) + @cached_property + def prime_rates(self) -> AsyncPrimeRates: + return AsyncPrimeRates(self._client) + @cached_property def with_raw_response(self) -> AsyncCreditProductsWithRawResponse: """ @@ -74,6 +90,10 @@ def __init__(self, credit_products: CreditProducts) -> None: def extended_credit(self) -> ExtendedCreditResourceWithRawResponse: return ExtendedCreditResourceWithRawResponse(self._credit_products.extended_credit) + @cached_property + def prime_rates(self) -> PrimeRatesWithRawResponse: + return PrimeRatesWithRawResponse(self._credit_products.prime_rates) + class AsyncCreditProductsWithRawResponse: def __init__(self, credit_products: AsyncCreditProducts) -> None: @@ -83,6 +103,10 @@ def __init__(self, credit_products: AsyncCreditProducts) -> None: def extended_credit(self) -> AsyncExtendedCreditResourceWithRawResponse: return AsyncExtendedCreditResourceWithRawResponse(self._credit_products.extended_credit) + @cached_property + def prime_rates(self) -> AsyncPrimeRatesWithRawResponse: + return AsyncPrimeRatesWithRawResponse(self._credit_products.prime_rates) + class CreditProductsWithStreamingResponse: def __init__(self, credit_products: CreditProducts) -> None: @@ -92,6 +116,10 @@ def __init__(self, credit_products: CreditProducts) -> None: def extended_credit(self) -> ExtendedCreditResourceWithStreamingResponse: return ExtendedCreditResourceWithStreamingResponse(self._credit_products.extended_credit) + @cached_property + def prime_rates(self) -> PrimeRatesWithStreamingResponse: + return PrimeRatesWithStreamingResponse(self._credit_products.prime_rates) + class AsyncCreditProductsWithStreamingResponse: def __init__(self, credit_products: AsyncCreditProducts) -> None: @@ -100,3 +128,7 @@ def __init__(self, credit_products: AsyncCreditProducts) -> None: @cached_property def extended_credit(self) -> AsyncExtendedCreditResourceWithStreamingResponse: return AsyncExtendedCreditResourceWithStreamingResponse(self._credit_products.extended_credit) + + @cached_property + def prime_rates(self) -> AsyncPrimeRatesWithStreamingResponse: + return AsyncPrimeRatesWithStreamingResponse(self._credit_products.prime_rates) diff --git a/src/lithic/resources/credit_products/extended_credit.py b/src/lithic/resources/credit_products/extended_credit.py index 246ab8bd..2b298545 100644 --- a/src/lithic/resources/credit_products/extended_credit.py +++ b/src/lithic/resources/credit_products/extended_credit.py @@ -37,7 +37,7 @@ def with_streaming_response(self) -> ExtendedCreditResourceWithStreamingResponse def retrieve( self, - credit_product_id: str, + credit_product_token: str, *, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. # The extra values given here take precedence over values defined on the client or passed to this method. @@ -58,10 +58,12 @@ def retrieve( timeout: Override the client-level default timeout for this request, in seconds """ - if not credit_product_id: - raise ValueError(f"Expected a non-empty value for `credit_product_id` but received {credit_product_id!r}") + if not credit_product_token: + raise ValueError( + f"Expected a non-empty value for `credit_product_token` but received {credit_product_token!r}" + ) return self._get( - f"/v1/credit_products/{credit_product_id}/extended_credit", + f"/v1/credit_products/{credit_product_token}/extended_credit", options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), @@ -91,7 +93,7 @@ def with_streaming_response(self) -> AsyncExtendedCreditResourceWithStreamingRes async def retrieve( self, - credit_product_id: str, + credit_product_token: str, *, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. # The extra values given here take precedence over values defined on the client or passed to this method. @@ -112,10 +114,12 @@ async def retrieve( timeout: Override the client-level default timeout for this request, in seconds """ - if not credit_product_id: - raise ValueError(f"Expected a non-empty value for `credit_product_id` but received {credit_product_id!r}") + if not credit_product_token: + raise ValueError( + f"Expected a non-empty value for `credit_product_token` but received {credit_product_token!r}" + ) return await self._get( - f"/v1/credit_products/{credit_product_id}/extended_credit", + f"/v1/credit_products/{credit_product_token}/extended_credit", options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), diff --git a/src/lithic/resources/credit_products/prime_rates.py b/src/lithic/resources/credit_products/prime_rates.py new file mode 100644 index 00000000..3c570a4b --- /dev/null +++ b/src/lithic/resources/credit_products/prime_rates.py @@ -0,0 +1,319 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from datetime import date + +import httpx + +from ... import _legacy_response +from ..._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven +from ..._utils import ( + maybe_transform, + async_maybe_transform, +) +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper +from ..._base_client import make_request_options +from ...types.credit_products import prime_rate_create_params, prime_rate_retrieve_params +from ...types.credit_products.prime_rate_retrieve_response import PrimeRateRetrieveResponse + +__all__ = ["PrimeRates", "AsyncPrimeRates"] + + +class PrimeRates(SyncAPIResource): + @cached_property + def with_raw_response(self) -> PrimeRatesWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return the + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/lithic-com/lithic-python#accessing-raw-response-data-eg-headers + """ + return PrimeRatesWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> PrimeRatesWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/lithic-com/lithic-python#with_streaming_response + """ + return PrimeRatesWithStreamingResponse(self) + + def create( + self, + credit_product_token: str, + *, + effective_date: Union[str, date], + rate: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> None: + """ + Post Credit Product Prime Rate + + Args: + credit_product_token: Globally unique identifier for credit products. + + effective_date: Date the rate goes into effect + + rate: The rate in decimal format + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not credit_product_token: + raise ValueError( + f"Expected a non-empty value for `credit_product_token` but received {credit_product_token!r}" + ) + return self._post( + f"/v1/credit_products/{credit_product_token}/prime_rates", + body=maybe_transform( + { + "effective_date": effective_date, + "rate": rate, + }, + prime_rate_create_params.PrimeRateCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + + def retrieve( + self, + credit_product_token: str, + *, + ending_before: Union[str, date] | NotGiven = NOT_GIVEN, + starting_after: Union[str, date] | NotGiven = NOT_GIVEN, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> PrimeRateRetrieveResponse: + """ + Get Credit Product Prime Rates + + Args: + credit_product_token: Globally unique identifier for credit products. + + ending_before: The effective date that the prime rates ends before + + starting_after: The effective date that the prime rate starts after + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not credit_product_token: + raise ValueError( + f"Expected a non-empty value for `credit_product_token` but received {credit_product_token!r}" + ) + return self._get( + f"/v1/credit_products/{credit_product_token}/prime_rates", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "ending_before": ending_before, + "starting_after": starting_after, + }, + prime_rate_retrieve_params.PrimeRateRetrieveParams, + ), + ), + cast_to=PrimeRateRetrieveResponse, + ) + + +class AsyncPrimeRates(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncPrimeRatesWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return the + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/lithic-com/lithic-python#accessing-raw-response-data-eg-headers + """ + return AsyncPrimeRatesWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncPrimeRatesWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/lithic-com/lithic-python#with_streaming_response + """ + return AsyncPrimeRatesWithStreamingResponse(self) + + async def create( + self, + credit_product_token: str, + *, + effective_date: Union[str, date], + rate: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> None: + """ + Post Credit Product Prime Rate + + Args: + credit_product_token: Globally unique identifier for credit products. + + effective_date: Date the rate goes into effect + + rate: The rate in decimal format + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not credit_product_token: + raise ValueError( + f"Expected a non-empty value for `credit_product_token` but received {credit_product_token!r}" + ) + return await self._post( + f"/v1/credit_products/{credit_product_token}/prime_rates", + body=await async_maybe_transform( + { + "effective_date": effective_date, + "rate": rate, + }, + prime_rate_create_params.PrimeRateCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + + async def retrieve( + self, + credit_product_token: str, + *, + ending_before: Union[str, date] | NotGiven = NOT_GIVEN, + starting_after: Union[str, date] | NotGiven = NOT_GIVEN, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> PrimeRateRetrieveResponse: + """ + Get Credit Product Prime Rates + + Args: + credit_product_token: Globally unique identifier for credit products. + + ending_before: The effective date that the prime rates ends before + + starting_after: The effective date that the prime rate starts after + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not credit_product_token: + raise ValueError( + f"Expected a non-empty value for `credit_product_token` but received {credit_product_token!r}" + ) + return await self._get( + f"/v1/credit_products/{credit_product_token}/prime_rates", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + { + "ending_before": ending_before, + "starting_after": starting_after, + }, + prime_rate_retrieve_params.PrimeRateRetrieveParams, + ), + ), + cast_to=PrimeRateRetrieveResponse, + ) + + +class PrimeRatesWithRawResponse: + def __init__(self, prime_rates: PrimeRates) -> None: + self._prime_rates = prime_rates + + self.create = _legacy_response.to_raw_response_wrapper( + prime_rates.create, + ) + self.retrieve = _legacy_response.to_raw_response_wrapper( + prime_rates.retrieve, + ) + + +class AsyncPrimeRatesWithRawResponse: + def __init__(self, prime_rates: AsyncPrimeRates) -> None: + self._prime_rates = prime_rates + + self.create = _legacy_response.async_to_raw_response_wrapper( + prime_rates.create, + ) + self.retrieve = _legacy_response.async_to_raw_response_wrapper( + prime_rates.retrieve, + ) + + +class PrimeRatesWithStreamingResponse: + def __init__(self, prime_rates: PrimeRates) -> None: + self._prime_rates = prime_rates + + self.create = to_streamed_response_wrapper( + prime_rates.create, + ) + self.retrieve = to_streamed_response_wrapper( + prime_rates.retrieve, + ) + + +class AsyncPrimeRatesWithStreamingResponse: + def __init__(self, prime_rates: AsyncPrimeRates) -> None: + self._prime_rates = prime_rates + + self.create = async_to_streamed_response_wrapper( + prime_rates.create, + ) + self.retrieve = async_to_streamed_response_wrapper( + prime_rates.retrieve, + ) diff --git a/src/lithic/types/credit_products/__init__.py b/src/lithic/types/credit_products/__init__.py index c6222c96..adbd039a 100644 --- a/src/lithic/types/credit_products/__init__.py +++ b/src/lithic/types/credit_products/__init__.py @@ -3,3 +3,6 @@ from __future__ import annotations from .extended_credit import ExtendedCredit as ExtendedCredit +from .prime_rate_create_params import PrimeRateCreateParams as PrimeRateCreateParams +from .prime_rate_retrieve_params import PrimeRateRetrieveParams as PrimeRateRetrieveParams +from .prime_rate_retrieve_response import PrimeRateRetrieveResponse as PrimeRateRetrieveResponse diff --git a/src/lithic/types/credit_products/prime_rate_create_params.py b/src/lithic/types/credit_products/prime_rate_create_params.py new file mode 100644 index 00000000..99ba37c6 --- /dev/null +++ b/src/lithic/types/credit_products/prime_rate_create_params.py @@ -0,0 +1,19 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from datetime import date +from typing_extensions import Required, Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["PrimeRateCreateParams"] + + +class PrimeRateCreateParams(TypedDict, total=False): + effective_date: Required[Annotated[Union[str, date], PropertyInfo(format="iso8601")]] + """Date the rate goes into effect""" + + rate: Required[str] + """The rate in decimal format""" diff --git a/src/lithic/types/credit_products/prime_rate_retrieve_params.py b/src/lithic/types/credit_products/prime_rate_retrieve_params.py new file mode 100644 index 00000000..2b61243a --- /dev/null +++ b/src/lithic/types/credit_products/prime_rate_retrieve_params.py @@ -0,0 +1,19 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from datetime import date +from typing_extensions import Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["PrimeRateRetrieveParams"] + + +class PrimeRateRetrieveParams(TypedDict, total=False): + ending_before: Annotated[Union[str, date], PropertyInfo(format="iso8601")] + """The effective date that the prime rates ends before""" + + starting_after: Annotated[Union[str, date], PropertyInfo(format="iso8601")] + """The effective date that the prime rate starts after""" diff --git a/src/lithic/types/credit_products/prime_rate_retrieve_response.py b/src/lithic/types/credit_products/prime_rate_retrieve_response.py new file mode 100644 index 00000000..5d4e3d92 --- /dev/null +++ b/src/lithic/types/credit_products/prime_rate_retrieve_response.py @@ -0,0 +1,24 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from datetime import date + +from ..._models import BaseModel + +__all__ = ["PrimeRateRetrieveResponse", "Data"] + + +class Data(BaseModel): + effective_date: date + """Date the rate goes into effect""" + + rate: str + """The rate in decimal format""" + + +class PrimeRateRetrieveResponse(BaseModel): + data: List[Data] + """List of prime rates""" + + has_more: bool + """Whether there are more prime rates""" diff --git a/src/lithic/types/financial_accounts/statements/line_item_list_response.py b/src/lithic/types/financial_accounts/statements/line_item_list_response.py index ffe750bf..73e12ea8 100644 --- a/src/lithic/types/financial_accounts/statements/line_item_list_response.py +++ b/src/lithic/types/financial_accounts/statements/line_item_list_response.py @@ -18,6 +18,7 @@ class LineItemListResponse(BaseModel): category: Literal[ "ACH", + "BALANCE_OR_FUNDING", "CARD", "EXTERNAL_ACH", "EXTERNAL_CHECK", @@ -56,6 +57,7 @@ class LineItemListResponse(BaseModel): "BALANCE_INQUIRY", "BILLING_ERROR", "BILLING_ERROR_REVERSAL", + "CARD_TO_CARD", "CASH_BACK", "CASH_BACK_REVERSAL", "CLEARING", diff --git a/src/lithic/types/financial_accounts/statements/statement_line_items.py b/src/lithic/types/financial_accounts/statements/statement_line_items.py index 04a163c5..692c8948 100644 --- a/src/lithic/types/financial_accounts/statements/statement_line_items.py +++ b/src/lithic/types/financial_accounts/statements/statement_line_items.py @@ -18,6 +18,7 @@ class Data(BaseModel): category: Literal[ "ACH", + "BALANCE_OR_FUNDING", "CARD", "EXTERNAL_ACH", "EXTERNAL_CHECK", @@ -56,6 +57,7 @@ class Data(BaseModel): "BALANCE_INQUIRY", "BILLING_ERROR", "BILLING_ERROR_REVERSAL", + "CARD_TO_CARD", "CASH_BACK", "CASH_BACK_REVERSAL", "CLEARING", diff --git a/src/lithic/types/financial_transaction.py b/src/lithic/types/financial_transaction.py index 8fee2ecd..d50f4720 100644 --- a/src/lithic/types/financial_transaction.py +++ b/src/lithic/types/financial_transaction.py @@ -47,6 +47,7 @@ class Event(BaseModel): "BALANCE_INQUIRY", "BILLING_ERROR", "BILLING_ERROR_REVERSAL", + "CARD_TO_CARD", "CASH_BACK", "CASH_BACK_REVERSAL", "CLEARING", diff --git a/tests/api_resources/credit_products/test_extended_credit.py b/tests/api_resources/credit_products/test_extended_credit.py index 3409b732..46b755db 100644 --- a/tests/api_resources/credit_products/test_extended_credit.py +++ b/tests/api_resources/credit_products/test_extended_credit.py @@ -20,14 +20,14 @@ class TestExtendedCredit: @parametrize def test_method_retrieve(self, client: Lithic) -> None: extended_credit = client.credit_products.extended_credit.retrieve( - "credit_product_id", + "credit_product_token", ) assert_matches_type(ExtendedCredit, extended_credit, path=["response"]) @parametrize def test_raw_response_retrieve(self, client: Lithic) -> None: response = client.credit_products.extended_credit.with_raw_response.retrieve( - "credit_product_id", + "credit_product_token", ) assert response.is_closed is True @@ -38,7 +38,7 @@ def test_raw_response_retrieve(self, client: Lithic) -> None: @parametrize def test_streaming_response_retrieve(self, client: Lithic) -> None: with client.credit_products.extended_credit.with_streaming_response.retrieve( - "credit_product_id", + "credit_product_token", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -50,7 +50,7 @@ def test_streaming_response_retrieve(self, client: Lithic) -> None: @parametrize def test_path_params_retrieve(self, client: Lithic) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `credit_product_id` but received ''"): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `credit_product_token` but received ''"): client.credit_products.extended_credit.with_raw_response.retrieve( "", ) @@ -62,14 +62,14 @@ class TestAsyncExtendedCredit: @parametrize async def test_method_retrieve(self, async_client: AsyncLithic) -> None: extended_credit = await async_client.credit_products.extended_credit.retrieve( - "credit_product_id", + "credit_product_token", ) assert_matches_type(ExtendedCredit, extended_credit, path=["response"]) @parametrize async def test_raw_response_retrieve(self, async_client: AsyncLithic) -> None: response = await async_client.credit_products.extended_credit.with_raw_response.retrieve( - "credit_product_id", + "credit_product_token", ) assert response.is_closed is True @@ -80,7 +80,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncLithic) -> None: @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncLithic) -> None: async with async_client.credit_products.extended_credit.with_streaming_response.retrieve( - "credit_product_id", + "credit_product_token", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -92,7 +92,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncLithic) -> N @parametrize async def test_path_params_retrieve(self, async_client: AsyncLithic) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `credit_product_id` but received ''"): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `credit_product_token` but received ''"): await async_client.credit_products.extended_credit.with_raw_response.retrieve( "", ) diff --git a/tests/api_resources/credit_products/test_prime_rates.py b/tests/api_resources/credit_products/test_prime_rates.py new file mode 100644 index 00000000..3534a8de --- /dev/null +++ b/tests/api_resources/credit_products/test_prime_rates.py @@ -0,0 +1,209 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from lithic import Lithic, AsyncLithic +from tests.utils import assert_matches_type +from lithic._utils import parse_date +from lithic.types.credit_products import PrimeRateRetrieveResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestPrimeRates: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_create(self, client: Lithic) -> None: + prime_rate = client.credit_products.prime_rates.create( + credit_product_token="credit_product_token", + effective_date=parse_date("2019-12-27"), + rate="rate", + ) + assert prime_rate is None + + @parametrize + def test_raw_response_create(self, client: Lithic) -> None: + response = client.credit_products.prime_rates.with_raw_response.create( + credit_product_token="credit_product_token", + effective_date=parse_date("2019-12-27"), + rate="rate", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prime_rate = response.parse() + assert prime_rate is None + + @parametrize + def test_streaming_response_create(self, client: Lithic) -> None: + with client.credit_products.prime_rates.with_streaming_response.create( + credit_product_token="credit_product_token", + effective_date=parse_date("2019-12-27"), + rate="rate", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prime_rate = response.parse() + assert prime_rate is None + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_create(self, client: Lithic) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `credit_product_token` but received ''"): + client.credit_products.prime_rates.with_raw_response.create( + credit_product_token="", + effective_date=parse_date("2019-12-27"), + rate="rate", + ) + + @parametrize + def test_method_retrieve(self, client: Lithic) -> None: + prime_rate = client.credit_products.prime_rates.retrieve( + credit_product_token="credit_product_token", + ) + assert_matches_type(PrimeRateRetrieveResponse, prime_rate, path=["response"]) + + @parametrize + def test_method_retrieve_with_all_params(self, client: Lithic) -> None: + prime_rate = client.credit_products.prime_rates.retrieve( + credit_product_token="credit_product_token", + ending_before=parse_date("2019-12-27"), + starting_after=parse_date("2019-12-27"), + ) + assert_matches_type(PrimeRateRetrieveResponse, prime_rate, path=["response"]) + + @parametrize + def test_raw_response_retrieve(self, client: Lithic) -> None: + response = client.credit_products.prime_rates.with_raw_response.retrieve( + credit_product_token="credit_product_token", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prime_rate = response.parse() + assert_matches_type(PrimeRateRetrieveResponse, prime_rate, path=["response"]) + + @parametrize + def test_streaming_response_retrieve(self, client: Lithic) -> None: + with client.credit_products.prime_rates.with_streaming_response.retrieve( + credit_product_token="credit_product_token", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prime_rate = response.parse() + assert_matches_type(PrimeRateRetrieveResponse, prime_rate, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_retrieve(self, client: Lithic) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `credit_product_token` but received ''"): + client.credit_products.prime_rates.with_raw_response.retrieve( + credit_product_token="", + ) + + +class TestAsyncPrimeRates: + parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + async def test_method_create(self, async_client: AsyncLithic) -> None: + prime_rate = await async_client.credit_products.prime_rates.create( + credit_product_token="credit_product_token", + effective_date=parse_date("2019-12-27"), + rate="rate", + ) + assert prime_rate is None + + @parametrize + async def test_raw_response_create(self, async_client: AsyncLithic) -> None: + response = await async_client.credit_products.prime_rates.with_raw_response.create( + credit_product_token="credit_product_token", + effective_date=parse_date("2019-12-27"), + rate="rate", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prime_rate = response.parse() + assert prime_rate is None + + @parametrize + async def test_streaming_response_create(self, async_client: AsyncLithic) -> None: + async with async_client.credit_products.prime_rates.with_streaming_response.create( + credit_product_token="credit_product_token", + effective_date=parse_date("2019-12-27"), + rate="rate", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prime_rate = await response.parse() + assert prime_rate is None + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_create(self, async_client: AsyncLithic) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `credit_product_token` but received ''"): + await async_client.credit_products.prime_rates.with_raw_response.create( + credit_product_token="", + effective_date=parse_date("2019-12-27"), + rate="rate", + ) + + @parametrize + async def test_method_retrieve(self, async_client: AsyncLithic) -> None: + prime_rate = await async_client.credit_products.prime_rates.retrieve( + credit_product_token="credit_product_token", + ) + assert_matches_type(PrimeRateRetrieveResponse, prime_rate, path=["response"]) + + @parametrize + async def test_method_retrieve_with_all_params(self, async_client: AsyncLithic) -> None: + prime_rate = await async_client.credit_products.prime_rates.retrieve( + credit_product_token="credit_product_token", + ending_before=parse_date("2019-12-27"), + starting_after=parse_date("2019-12-27"), + ) + assert_matches_type(PrimeRateRetrieveResponse, prime_rate, path=["response"]) + + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncLithic) -> None: + response = await async_client.credit_products.prime_rates.with_raw_response.retrieve( + credit_product_token="credit_product_token", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prime_rate = response.parse() + assert_matches_type(PrimeRateRetrieveResponse, prime_rate, path=["response"]) + + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncLithic) -> None: + async with async_client.credit_products.prime_rates.with_streaming_response.retrieve( + credit_product_token="credit_product_token", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prime_rate = await response.parse() + assert_matches_type(PrimeRateRetrieveResponse, prime_rate, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncLithic) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `credit_product_token` but received ''"): + await async_client.credit_products.prime_rates.with_raw_response.retrieve( + credit_product_token="", + )