From 4346b67da1382b459c3c41f2ca896a0b4a269d7e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Jun 2024 22:13:41 +0000 Subject: [PATCH 1/2] feat(api): updates (#398) --- .stats.yml | 4 +- api.md | 15 ++ src/finch/_client.py | 8 + src/finch/resources/__init__.py | 14 + src/finch/resources/payroll/__init__.py | 33 +++ src/finch/resources/payroll/pay_groups.py | 244 ++++++++++++++++++ src/finch/resources/payroll/payroll.py | 80 ++++++ src/finch/types/payroll/__init__.py | 7 + .../types/payroll/pay_group_list_params.py | 14 + .../types/payroll/pay_group_list_response.py | 33 +++ .../payroll/pay_group_retrieve_response.py | 25 ++ tests/api_resources/payroll/__init__.py | 1 + .../api_resources/payroll/test_pay_groups.py | 165 ++++++++++++ 13 files changed, 641 insertions(+), 2 deletions(-) create mode 100644 src/finch/resources/payroll/__init__.py create mode 100644 src/finch/resources/payroll/pay_groups.py create mode 100644 src/finch/resources/payroll/payroll.py create mode 100644 src/finch/types/payroll/__init__.py create mode 100644 src/finch/types/payroll/pay_group_list_params.py create mode 100644 src/finch/types/payroll/pay_group_list_response.py create mode 100644 src/finch/types/payroll/pay_group_retrieve_response.py create mode 100644 tests/api_resources/payroll/__init__.py create mode 100644 tests/api_resources/payroll/test_pay_groups.py diff --git a/.stats.yml b/.stats.yml index c423dd6b..417d1dea 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,2 +1,2 @@ -configured_endpoints: 35 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/finch-69265939ed1aa33d9890c86a334730210985961db56757efc28ff43696fbd1a7.yml +configured_endpoints: 37 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/finch-f1001da4ad3c1503330eebc1e61319a1a5db5e2da9fec98bc8682cb0967894d2.yml diff --git a/api.md b/api.md index 7ddec77b..9327ae2a 100644 --- a/api.md +++ b/api.md @@ -351,3 +351,18 @@ Methods: - client.sandbox.jobs.configuration.retrieve() -> ConfigurationRetrieveResponse - client.sandbox.jobs.configuration.update(\*\*params) -> SandboxJobConfiguration + +# Payroll + +## PayGroups + +Types: + +```python +from finch.types.payroll import PayGroupRetrieveResponse, PayGroupListResponse +``` + +Methods: + +- client.payroll.pay_groups.retrieve(pay_group_id) -> PayGroupRetrieveResponse +- client.payroll.pay_groups.list(\*\*params) -> SyncSinglePage[PayGroupListResponse] diff --git a/src/finch/_client.py b/src/finch/_client.py index 246de6a3..3e9651e6 100644 --- a/src/finch/_client.py +++ b/src/finch/_client.py @@ -60,6 +60,7 @@ class Finch(SyncAPIClient): request_forwarding: resources.RequestForwarding jobs: resources.Jobs sandbox: resources.Sandbox + payroll: resources.Payroll with_raw_response: FinchWithRawResponse with_streaming_response: FinchWithStreamedResponse @@ -163,6 +164,7 @@ def __init__( self.request_forwarding = resources.RequestForwarding(self) self.jobs = resources.Jobs(self) self.sandbox = resources.Sandbox(self) + self.payroll = resources.Payroll(self) self.with_raw_response = FinchWithRawResponse(self) self.with_streaming_response = FinchWithStreamedResponse(self) @@ -410,6 +412,7 @@ class AsyncFinch(AsyncAPIClient): request_forwarding: resources.AsyncRequestForwarding jobs: resources.AsyncJobs sandbox: resources.AsyncSandbox + payroll: resources.AsyncPayroll with_raw_response: AsyncFinchWithRawResponse with_streaming_response: AsyncFinchWithStreamedResponse @@ -513,6 +516,7 @@ def __init__( self.request_forwarding = resources.AsyncRequestForwarding(self) self.jobs = resources.AsyncJobs(self) self.sandbox = resources.AsyncSandbox(self) + self.payroll = resources.AsyncPayroll(self) self.with_raw_response = AsyncFinchWithRawResponse(self) self.with_streaming_response = AsyncFinchWithStreamedResponse(self) @@ -760,6 +764,7 @@ def __init__(self, client: Finch) -> None: self.request_forwarding = resources.RequestForwardingWithRawResponse(client.request_forwarding) self.jobs = resources.JobsWithRawResponse(client.jobs) self.sandbox = resources.SandboxWithRawResponse(client.sandbox) + self.payroll = resources.PayrollWithRawResponse(client.payroll) class AsyncFinchWithRawResponse: @@ -771,6 +776,7 @@ def __init__(self, client: AsyncFinch) -> None: self.request_forwarding = resources.AsyncRequestForwardingWithRawResponse(client.request_forwarding) self.jobs = resources.AsyncJobsWithRawResponse(client.jobs) self.sandbox = resources.AsyncSandboxWithRawResponse(client.sandbox) + self.payroll = resources.AsyncPayrollWithRawResponse(client.payroll) class FinchWithStreamedResponse: @@ -782,6 +788,7 @@ def __init__(self, client: Finch) -> None: self.request_forwarding = resources.RequestForwardingWithStreamingResponse(client.request_forwarding) self.jobs = resources.JobsWithStreamingResponse(client.jobs) self.sandbox = resources.SandboxWithStreamingResponse(client.sandbox) + self.payroll = resources.PayrollWithStreamingResponse(client.payroll) class AsyncFinchWithStreamedResponse: @@ -793,6 +800,7 @@ def __init__(self, client: AsyncFinch) -> None: self.request_forwarding = resources.AsyncRequestForwardingWithStreamingResponse(client.request_forwarding) self.jobs = resources.AsyncJobsWithStreamingResponse(client.jobs) self.sandbox = resources.AsyncSandboxWithStreamingResponse(client.sandbox) + self.payroll = resources.AsyncPayrollWithStreamingResponse(client.payroll) Client = Finch diff --git a/src/finch/resources/__init__.py b/src/finch/resources/__init__.py index d5f226e9..6f6a8cdc 100644 --- a/src/finch/resources/__init__.py +++ b/src/finch/resources/__init__.py @@ -24,6 +24,14 @@ AccountWithStreamingResponse, AsyncAccountWithStreamingResponse, ) +from .payroll import ( + Payroll, + AsyncPayroll, + PayrollWithRawResponse, + AsyncPayrollWithRawResponse, + PayrollWithStreamingResponse, + AsyncPayrollWithStreamingResponse, +) from .sandbox import ( Sandbox, AsyncSandbox, @@ -103,4 +111,10 @@ "AsyncSandboxWithRawResponse", "SandboxWithStreamingResponse", "AsyncSandboxWithStreamingResponse", + "Payroll", + "AsyncPayroll", + "PayrollWithRawResponse", + "AsyncPayrollWithRawResponse", + "PayrollWithStreamingResponse", + "AsyncPayrollWithStreamingResponse", ] diff --git a/src/finch/resources/payroll/__init__.py b/src/finch/resources/payroll/__init__.py new file mode 100644 index 00000000..6b33267c --- /dev/null +++ b/src/finch/resources/payroll/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .payroll import ( + Payroll, + AsyncPayroll, + PayrollWithRawResponse, + AsyncPayrollWithRawResponse, + PayrollWithStreamingResponse, + AsyncPayrollWithStreamingResponse, +) +from .pay_groups import ( + PayGroups, + AsyncPayGroups, + PayGroupsWithRawResponse, + AsyncPayGroupsWithRawResponse, + PayGroupsWithStreamingResponse, + AsyncPayGroupsWithStreamingResponse, +) + +__all__ = [ + "PayGroups", + "AsyncPayGroups", + "PayGroupsWithRawResponse", + "AsyncPayGroupsWithRawResponse", + "PayGroupsWithStreamingResponse", + "AsyncPayGroupsWithStreamingResponse", + "Payroll", + "AsyncPayroll", + "PayrollWithRawResponse", + "AsyncPayrollWithRawResponse", + "PayrollWithStreamingResponse", + "AsyncPayrollWithStreamingResponse", +] diff --git a/src/finch/resources/payroll/pay_groups.py b/src/finch/resources/payroll/pay_groups.py new file mode 100644 index 00000000..e423b24a --- /dev/null +++ b/src/finch/resources/payroll/pay_groups.py @@ -0,0 +1,244 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List + +import httpx + +from ... import _legacy_response +from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..._utils import 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 ...pagination import SyncSinglePage, AsyncSinglePage +from ..._base_client import ( + AsyncPaginator, + make_request_options, +) +from ...types.payroll import pay_group_list_params +from ...types.payroll.pay_group_list_response import PayGroupListResponse +from ...types.payroll.pay_group_retrieve_response import PayGroupRetrieveResponse + +__all__ = ["PayGroups", "AsyncPayGroups"] + + +class PayGroups(SyncAPIResource): + @cached_property + def with_raw_response(self) -> PayGroupsWithRawResponse: + return PayGroupsWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> PayGroupsWithStreamingResponse: + return PayGroupsWithStreamingResponse(self) + + def retrieve( + self, + pay_group_id: 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, + ) -> PayGroupRetrieveResponse: + """ + Read information from a single pay group + + Args: + 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 pay_group_id: + raise ValueError(f"Expected a non-empty value for `pay_group_id` but received {pay_group_id!r}") + return self._get( + f"/employer/pay-group/{pay_group_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=PayGroupRetrieveResponse, + ) + + def list( + self, + *, + individual_id: str | NotGiven = NOT_GIVEN, + pay_frequencies: List[str] | 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, + ) -> SyncSinglePage[PayGroupListResponse]: + """ + Read company pay groups and frequencies + + Args: + 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 + """ + return self._get_api_list( + "/employer/pay-groups", + page=SyncSinglePage[PayGroupListResponse], + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "individual_id": individual_id, + "pay_frequencies": pay_frequencies, + }, + pay_group_list_params.PayGroupListParams, + ), + ), + model=PayGroupListResponse, + ) + + +class AsyncPayGroups(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncPayGroupsWithRawResponse: + return AsyncPayGroupsWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncPayGroupsWithStreamingResponse: + return AsyncPayGroupsWithStreamingResponse(self) + + async def retrieve( + self, + pay_group_id: 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, + ) -> PayGroupRetrieveResponse: + """ + Read information from a single pay group + + Args: + 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 pay_group_id: + raise ValueError(f"Expected a non-empty value for `pay_group_id` but received {pay_group_id!r}") + return await self._get( + f"/employer/pay-group/{pay_group_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=PayGroupRetrieveResponse, + ) + + def list( + self, + *, + individual_id: str | NotGiven = NOT_GIVEN, + pay_frequencies: List[str] | 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, + ) -> AsyncPaginator[PayGroupListResponse, AsyncSinglePage[PayGroupListResponse]]: + """ + Read company pay groups and frequencies + + Args: + 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 + """ + return self._get_api_list( + "/employer/pay-groups", + page=AsyncSinglePage[PayGroupListResponse], + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "individual_id": individual_id, + "pay_frequencies": pay_frequencies, + }, + pay_group_list_params.PayGroupListParams, + ), + ), + model=PayGroupListResponse, + ) + + +class PayGroupsWithRawResponse: + def __init__(self, pay_groups: PayGroups) -> None: + self._pay_groups = pay_groups + + self.retrieve = _legacy_response.to_raw_response_wrapper( + pay_groups.retrieve, + ) + self.list = _legacy_response.to_raw_response_wrapper( + pay_groups.list, + ) + + +class AsyncPayGroupsWithRawResponse: + def __init__(self, pay_groups: AsyncPayGroups) -> None: + self._pay_groups = pay_groups + + self.retrieve = _legacy_response.async_to_raw_response_wrapper( + pay_groups.retrieve, + ) + self.list = _legacy_response.async_to_raw_response_wrapper( + pay_groups.list, + ) + + +class PayGroupsWithStreamingResponse: + def __init__(self, pay_groups: PayGroups) -> None: + self._pay_groups = pay_groups + + self.retrieve = to_streamed_response_wrapper( + pay_groups.retrieve, + ) + self.list = to_streamed_response_wrapper( + pay_groups.list, + ) + + +class AsyncPayGroupsWithStreamingResponse: + def __init__(self, pay_groups: AsyncPayGroups) -> None: + self._pay_groups = pay_groups + + self.retrieve = async_to_streamed_response_wrapper( + pay_groups.retrieve, + ) + self.list = async_to_streamed_response_wrapper( + pay_groups.list, + ) diff --git a/src/finch/resources/payroll/payroll.py b/src/finch/resources/payroll/payroll.py new file mode 100644 index 00000000..01bebaa6 --- /dev/null +++ b/src/finch/resources/payroll/payroll.py @@ -0,0 +1,80 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from ..._compat import cached_property +from .pay_groups import ( + PayGroups, + AsyncPayGroups, + PayGroupsWithRawResponse, + AsyncPayGroupsWithRawResponse, + PayGroupsWithStreamingResponse, + AsyncPayGroupsWithStreamingResponse, +) +from ..._resource import SyncAPIResource, AsyncAPIResource + +__all__ = ["Payroll", "AsyncPayroll"] + + +class Payroll(SyncAPIResource): + @cached_property + def pay_groups(self) -> PayGroups: + return PayGroups(self._client) + + @cached_property + def with_raw_response(self) -> PayrollWithRawResponse: + return PayrollWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> PayrollWithStreamingResponse: + return PayrollWithStreamingResponse(self) + + +class AsyncPayroll(AsyncAPIResource): + @cached_property + def pay_groups(self) -> AsyncPayGroups: + return AsyncPayGroups(self._client) + + @cached_property + def with_raw_response(self) -> AsyncPayrollWithRawResponse: + return AsyncPayrollWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncPayrollWithStreamingResponse: + return AsyncPayrollWithStreamingResponse(self) + + +class PayrollWithRawResponse: + def __init__(self, payroll: Payroll) -> None: + self._payroll = payroll + + @cached_property + def pay_groups(self) -> PayGroupsWithRawResponse: + return PayGroupsWithRawResponse(self._payroll.pay_groups) + + +class AsyncPayrollWithRawResponse: + def __init__(self, payroll: AsyncPayroll) -> None: + self._payroll = payroll + + @cached_property + def pay_groups(self) -> AsyncPayGroupsWithRawResponse: + return AsyncPayGroupsWithRawResponse(self._payroll.pay_groups) + + +class PayrollWithStreamingResponse: + def __init__(self, payroll: Payroll) -> None: + self._payroll = payroll + + @cached_property + def pay_groups(self) -> PayGroupsWithStreamingResponse: + return PayGroupsWithStreamingResponse(self._payroll.pay_groups) + + +class AsyncPayrollWithStreamingResponse: + def __init__(self, payroll: AsyncPayroll) -> None: + self._payroll = payroll + + @cached_property + def pay_groups(self) -> AsyncPayGroupsWithStreamingResponse: + return AsyncPayGroupsWithStreamingResponse(self._payroll.pay_groups) diff --git a/src/finch/types/payroll/__init__.py b/src/finch/types/payroll/__init__.py new file mode 100644 index 00000000..f98e6098 --- /dev/null +++ b/src/finch/types/payroll/__init__.py @@ -0,0 +1,7 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from .pay_group_list_params import PayGroupListParams as PayGroupListParams +from .pay_group_list_response import PayGroupListResponse as PayGroupListResponse +from .pay_group_retrieve_response import PayGroupRetrieveResponse as PayGroupRetrieveResponse diff --git a/src/finch/types/payroll/pay_group_list_params.py b/src/finch/types/payroll/pay_group_list_params.py new file mode 100644 index 00000000..1e33abf4 --- /dev/null +++ b/src/finch/types/payroll/pay_group_list_params.py @@ -0,0 +1,14 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List +from typing_extensions import TypedDict + +__all__ = ["PayGroupListParams"] + + +class PayGroupListParams(TypedDict, total=False): + individual_id: str + + pay_frequencies: List[str] diff --git a/src/finch/types/payroll/pay_group_list_response.py b/src/finch/types/payroll/pay_group_list_response.py new file mode 100644 index 00000000..cd25dfcc --- /dev/null +++ b/src/finch/types/payroll/pay_group_list_response.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from typing_extensions import Literal + +from ..._models import BaseModel + +__all__ = ["PayGroupListResponse"] + + +class PayGroupListResponse(BaseModel): + id: Optional[str] = None + """Finch id (uuidv4) for the pay group""" + + name: Optional[str] = None + """Name of the pay group""" + + pay_frequencies: Optional[ + List[ + Literal[ + "annually", + "semi_annually", + "quarterly", + "monthly", + "semi_monthly", + "bi_weekly", + "weekly", + "daily", + "other", + ] + ] + ] = None + """List of pay frequencies associated with this pay group""" diff --git a/src/finch/types/payroll/pay_group_retrieve_response.py b/src/finch/types/payroll/pay_group_retrieve_response.py new file mode 100644 index 00000000..b07ec41c --- /dev/null +++ b/src/finch/types/payroll/pay_group_retrieve_response.py @@ -0,0 +1,25 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import Literal + +from ..._models import BaseModel + +__all__ = ["PayGroupRetrieveResponse"] + + +class PayGroupRetrieveResponse(BaseModel): + id: str + """Finch id (uuidv4) for the pay group""" + + individual_ids: List[str] + + name: str + """Name of the pay group""" + + pay_frequencies: List[ + Literal[ + "annually", "semi_annually", "quarterly", "monthly", "semi_monthly", "bi_weekly", "weekly", "daily", "other" + ] + ] + """List of pay frequencies associated with this pay group""" diff --git a/tests/api_resources/payroll/__init__.py b/tests/api_resources/payroll/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/payroll/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/payroll/test_pay_groups.py b/tests/api_resources/payroll/test_pay_groups.py new file mode 100644 index 00000000..1eeaf7f9 --- /dev/null +++ b/tests/api_resources/payroll/test_pay_groups.py @@ -0,0 +1,165 @@ +# 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 finch import Finch, AsyncFinch +from tests.utils import assert_matches_type +from finch.pagination import SyncSinglePage, AsyncSinglePage +from finch.types.payroll import PayGroupListResponse, PayGroupRetrieveResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestPayGroups: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_retrieve(self, client: Finch) -> None: + pay_group = client.payroll.pay_groups.retrieve( + "string", + ) + assert_matches_type(PayGroupRetrieveResponse, pay_group, path=["response"]) + + @parametrize + def test_raw_response_retrieve(self, client: Finch) -> None: + response = client.payroll.pay_groups.with_raw_response.retrieve( + "string", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + pay_group = response.parse() + assert_matches_type(PayGroupRetrieveResponse, pay_group, path=["response"]) + + @parametrize + def test_streaming_response_retrieve(self, client: Finch) -> None: + with client.payroll.pay_groups.with_streaming_response.retrieve( + "string", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + pay_group = response.parse() + assert_matches_type(PayGroupRetrieveResponse, pay_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_retrieve(self, client: Finch) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `pay_group_id` but received ''"): + client.payroll.pay_groups.with_raw_response.retrieve( + "", + ) + + @parametrize + def test_method_list(self, client: Finch) -> None: + pay_group = client.payroll.pay_groups.list() + assert_matches_type(SyncSinglePage[PayGroupListResponse], pay_group, path=["response"]) + + @parametrize + def test_method_list_with_all_params(self, client: Finch) -> None: + pay_group = client.payroll.pay_groups.list( + individual_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + pay_frequencies=["string", "string", "string"], + ) + assert_matches_type(SyncSinglePage[PayGroupListResponse], pay_group, path=["response"]) + + @parametrize + def test_raw_response_list(self, client: Finch) -> None: + response = client.payroll.pay_groups.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + pay_group = response.parse() + assert_matches_type(SyncSinglePage[PayGroupListResponse], pay_group, path=["response"]) + + @parametrize + def test_streaming_response_list(self, client: Finch) -> None: + with client.payroll.pay_groups.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + pay_group = response.parse() + assert_matches_type(SyncSinglePage[PayGroupListResponse], pay_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncPayGroups: + parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + async def test_method_retrieve(self, async_client: AsyncFinch) -> None: + pay_group = await async_client.payroll.pay_groups.retrieve( + "string", + ) + assert_matches_type(PayGroupRetrieveResponse, pay_group, path=["response"]) + + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncFinch) -> None: + response = await async_client.payroll.pay_groups.with_raw_response.retrieve( + "string", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + pay_group = response.parse() + assert_matches_type(PayGroupRetrieveResponse, pay_group, path=["response"]) + + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncFinch) -> None: + async with async_client.payroll.pay_groups.with_streaming_response.retrieve( + "string", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + pay_group = await response.parse() + assert_matches_type(PayGroupRetrieveResponse, pay_group, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncFinch) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `pay_group_id` but received ''"): + await async_client.payroll.pay_groups.with_raw_response.retrieve( + "", + ) + + @parametrize + async def test_method_list(self, async_client: AsyncFinch) -> None: + pay_group = await async_client.payroll.pay_groups.list() + assert_matches_type(AsyncSinglePage[PayGroupListResponse], pay_group, path=["response"]) + + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncFinch) -> None: + pay_group = await async_client.payroll.pay_groups.list( + individual_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + pay_frequencies=["string", "string", "string"], + ) + assert_matches_type(AsyncSinglePage[PayGroupListResponse], pay_group, path=["response"]) + + @parametrize + async def test_raw_response_list(self, async_client: AsyncFinch) -> None: + response = await async_client.payroll.pay_groups.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + pay_group = response.parse() + assert_matches_type(AsyncSinglePage[PayGroupListResponse], pay_group, path=["response"]) + + @parametrize + async def test_streaming_response_list(self, async_client: AsyncFinch) -> None: + async with async_client.payroll.pay_groups.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + pay_group = await response.parse() + assert_matches_type(AsyncSinglePage[PayGroupListResponse], pay_group, path=["response"]) + + assert cast(Any, response.is_closed) is True From 377036ab30bf3ec1aaa7058e2fce9f5d44b9d4ae Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 6 Jun 2024 22:13:58 +0000 Subject: [PATCH 2/2] release: 0.21.0 --- .release-please-manifest.json | 2 +- CHANGELOG.md | 8 ++++++++ pyproject.toml | 2 +- src/finch/_version.py | 2 +- 4 files changed, 11 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 11f85acc..86b0e83d 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.20.10" + ".": "0.21.0" } \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index a54985ad..635d209d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.21.0 (2024-06-06) + +Full Changelog: [v0.20.10...v0.21.0](https://github.com/Finch-API/finch-api-python/compare/v0.20.10...v0.21.0) + +### Features + +* **api:** updates ([#398](https://github.com/Finch-API/finch-api-python/issues/398)) ([4346b67](https://github.com/Finch-API/finch-api-python/commit/4346b67da1382b459c3c41f2ca896a0b4a269d7e)) + ## 0.20.10 (2024-05-28) Full Changelog: [v0.20.9...v0.20.10](https://github.com/Finch-API/finch-api-python/compare/v0.20.9...v0.20.10) diff --git a/pyproject.toml b/pyproject.toml index 90344c94..85a67060 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "finch-api" -version = "0.20.10" +version = "0.21.0" description = "The official Python library for the Finch API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/finch/_version.py b/src/finch/_version.py index f1599b50..9807b0fa 100644 --- a/src/finch/_version.py +++ b/src/finch/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "finch" -__version__ = "0.20.10" # x-release-please-version +__version__ = "0.21.0" # x-release-please-version