From be578a165580f9409bad761e4d2ac36e17fd7590 Mon Sep 17 00:00:00 2001 From: stainless-bot Date: Tue, 17 Sep 2024 17:56:35 +0000 Subject: [PATCH] chore(internal): codegen related update --- README.md | 11 ++++++++++ pyproject.toml | 4 ---- src/finch/resources/access_tokens.py | 22 +++++++++++++++++++ src/finch/resources/account.py | 22 +++++++++++++++++++ src/finch/resources/hris/benefits/benefits.py | 22 +++++++++++++++++++ .../resources/hris/benefits/individuals.py | 22 +++++++++++++++++++ src/finch/resources/hris/company.py | 22 +++++++++++++++++++ src/finch/resources/hris/directory.py | 22 +++++++++++++++++++ src/finch/resources/hris/employments.py | 22 +++++++++++++++++++ src/finch/resources/hris/hris.py | 22 +++++++++++++++++++ src/finch/resources/hris/individuals.py | 22 +++++++++++++++++++ src/finch/resources/hris/pay_statements.py | 22 +++++++++++++++++++ src/finch/resources/hris/payments.py | 22 +++++++++++++++++++ src/finch/resources/jobs/automated.py | 22 +++++++++++++++++++ src/finch/resources/jobs/jobs.py | 22 +++++++++++++++++++ src/finch/resources/jobs/manual.py | 22 +++++++++++++++++++ src/finch/resources/payroll/pay_groups.py | 22 +++++++++++++++++++ src/finch/resources/payroll/payroll.py | 22 +++++++++++++++++++ src/finch/resources/providers.py | 22 +++++++++++++++++++ src/finch/resources/request_forwarding.py | 22 +++++++++++++++++++ src/finch/resources/sandbox/company.py | 22 +++++++++++++++++++ .../resources/sandbox/connections/accounts.py | 22 +++++++++++++++++++ .../sandbox/connections/connections.py | 22 +++++++++++++++++++ src/finch/resources/sandbox/directory.py | 22 +++++++++++++++++++ src/finch/resources/sandbox/employment.py | 22 +++++++++++++++++++ src/finch/resources/sandbox/individual.py | 22 +++++++++++++++++++ .../resources/sandbox/jobs/configuration.py | 22 +++++++++++++++++++ src/finch/resources/sandbox/jobs/jobs.py | 22 +++++++++++++++++++ src/finch/resources/sandbox/payment.py | 22 +++++++++++++++++++ src/finch/resources/sandbox/sandbox.py | 22 +++++++++++++++++++ 30 files changed, 627 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 3b5b865e..588e713d 100644 --- a/README.md +++ b/README.md @@ -393,6 +393,17 @@ We take backwards-compatibility seriously and work hard to ensure you can rely o We are keen for your feedback; please open an [issue](https://www.github.com/Finch-API/finch-api-python/issues) with questions, bugs, or suggestions. +### Determining the installed version + +If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version. + +You can determine the version that is being used at runtime with: + +```py +import finch +print(finch.__version__) +``` + ## Requirements Python 3.7 or higher. diff --git a/pyproject.toml b/pyproject.toml index ab02cb07..09aa0af1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -15,7 +15,6 @@ dependencies = [ "distro>=1.7.0, <2", "sniffio", "cached-property; python_version < '3.8'", - ] requires-python = ">= 3.7" classifiers = [ @@ -36,8 +35,6 @@ classifiers = [ "License :: OSI Approved :: Apache Software License" ] - - [project.urls] Homepage = "https://github.com/Finch-API/finch-api-python" Repository = "https://github.com/Finch-API/finch-api-python" @@ -59,7 +56,6 @@ dev-dependencies = [ "dirty-equals>=0.6.0", "importlib-metadata>=6.7.0", "rich>=13.7.1", - ] [tool.rye.scripts] diff --git a/src/finch/resources/access_tokens.py b/src/finch/resources/access_tokens.py index 08eec666..8eca4d21 100644 --- a/src/finch/resources/access_tokens.py +++ b/src/finch/resources/access_tokens.py @@ -23,10 +23,21 @@ class AccessTokens(SyncAPIResource): @cached_property def with_raw_response(self) -> AccessTokensWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AccessTokensWithRawResponse(self) @cached_property def with_streaming_response(self) -> AccessTokensWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AccessTokensWithStreamingResponse(self) def create( @@ -76,10 +87,21 @@ def create( class AsyncAccessTokens(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncAccessTokensWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncAccessTokensWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncAccessTokensWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncAccessTokensWithStreamingResponse(self) async def create( diff --git a/src/finch/resources/account.py b/src/finch/resources/account.py index 08622c07..4f65a979 100644 --- a/src/finch/resources/account.py +++ b/src/finch/resources/account.py @@ -19,10 +19,21 @@ class Account(SyncAPIResource): @cached_property def with_raw_response(self) -> AccountWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AccountWithRawResponse(self) @cached_property def with_streaming_response(self) -> AccountWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AccountWithStreamingResponse(self) def disconnect( @@ -67,10 +78,21 @@ def introspect( class AsyncAccount(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncAccountWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncAccountWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncAccountWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncAccountWithStreamingResponse(self) async def disconnect( diff --git a/src/finch/resources/hris/benefits/benefits.py b/src/finch/resources/hris/benefits/benefits.py index be079297..3305930f 100644 --- a/src/finch/resources/hris/benefits/benefits.py +++ b/src/finch/resources/hris/benefits/benefits.py @@ -43,10 +43,21 @@ def individuals(self) -> Individuals: @cached_property def with_raw_response(self) -> BenefitsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return BenefitsWithRawResponse(self) @cached_property def with_streaming_response(self) -> BenefitsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return BenefitsWithStreamingResponse(self) def create( @@ -216,10 +227,21 @@ def individuals(self) -> AsyncIndividuals: @cached_property def with_raw_response(self) -> AsyncBenefitsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncBenefitsWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncBenefitsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncBenefitsWithStreamingResponse(self) async def create( diff --git a/src/finch/resources/hris/benefits/individuals.py b/src/finch/resources/hris/benefits/individuals.py index 31d01a9f..3545ee98 100644 --- a/src/finch/resources/hris/benefits/individuals.py +++ b/src/finch/resources/hris/benefits/individuals.py @@ -30,10 +30,21 @@ class Individuals(SyncAPIResource): @cached_property def with_raw_response(self) -> IndividualsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return IndividualsWithRawResponse(self) @cached_property def with_streaming_response(self) -> IndividualsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return IndividualsWithStreamingResponse(self) def enroll_many( @@ -202,10 +213,21 @@ def unenroll_many( class AsyncIndividuals(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncIndividualsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncIndividualsWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncIndividualsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncIndividualsWithStreamingResponse(self) def enroll_many( diff --git a/src/finch/resources/hris/company.py b/src/finch/resources/hris/company.py index 0ff218fb..d1eb8491 100644 --- a/src/finch/resources/hris/company.py +++ b/src/finch/resources/hris/company.py @@ -18,10 +18,21 @@ class CompanyResource(SyncAPIResource): @cached_property def with_raw_response(self) -> CompanyResourceWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return CompanyResourceWithRawResponse(self) @cached_property def with_streaming_response(self) -> CompanyResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return CompanyResourceWithStreamingResponse(self) def retrieve( @@ -47,10 +58,21 @@ def retrieve( class AsyncCompanyResource(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncCompanyResourceWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncCompanyResourceWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncCompanyResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncCompanyResourceWithStreamingResponse(self) async def retrieve( diff --git a/src/finch/resources/hris/directory.py b/src/finch/resources/hris/directory.py index 3cb6bcb4..94a4451c 100644 --- a/src/finch/resources/hris/directory.py +++ b/src/finch/resources/hris/directory.py @@ -23,10 +23,21 @@ class Directory(SyncAPIResource): @cached_property def with_raw_response(self) -> DirectoryWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return DirectoryWithRawResponse(self) @cached_property def with_streaming_response(self) -> DirectoryWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return DirectoryWithStreamingResponse(self) def list( @@ -118,10 +129,21 @@ def list_individuals( class AsyncDirectory(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncDirectoryWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncDirectoryWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncDirectoryWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncDirectoryWithStreamingResponse(self) def list( diff --git a/src/finch/resources/hris/employments.py b/src/finch/resources/hris/employments.py index 867fcd20..1a562194 100644 --- a/src/finch/resources/hris/employments.py +++ b/src/finch/resources/hris/employments.py @@ -23,10 +23,21 @@ class Employments(SyncAPIResource): @cached_property def with_raw_response(self) -> EmploymentsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return EmploymentsWithRawResponse(self) @cached_property def with_streaming_response(self) -> EmploymentsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return EmploymentsWithStreamingResponse(self) def retrieve_many( @@ -69,10 +80,21 @@ def retrieve_many( class AsyncEmployments(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncEmploymentsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncEmploymentsWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncEmploymentsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncEmploymentsWithStreamingResponse(self) def retrieve_many( diff --git a/src/finch/resources/hris/hris.py b/src/finch/resources/hris/hris.py index 8a49bc85..50c5a621 100644 --- a/src/finch/resources/hris/hris.py +++ b/src/finch/resources/hris/hris.py @@ -96,10 +96,21 @@ def benefits(self) -> Benefits: @cached_property def with_raw_response(self) -> HRISWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return HRISWithRawResponse(self) @cached_property def with_streaming_response(self) -> HRISWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return HRISWithStreamingResponse(self) @@ -134,10 +145,21 @@ def benefits(self) -> AsyncBenefits: @cached_property def with_raw_response(self) -> AsyncHRISWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncHRISWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncHRISWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncHRISWithStreamingResponse(self) diff --git a/src/finch/resources/hris/individuals.py b/src/finch/resources/hris/individuals.py index 705ee584..7bf9b26b 100644 --- a/src/finch/resources/hris/individuals.py +++ b/src/finch/resources/hris/individuals.py @@ -23,10 +23,21 @@ class Individuals(SyncAPIResource): @cached_property def with_raw_response(self) -> IndividualsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return IndividualsWithRawResponse(self) @cached_property def with_streaming_response(self) -> IndividualsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return IndividualsWithStreamingResponse(self) def retrieve_many( @@ -74,10 +85,21 @@ def retrieve_many( class AsyncIndividuals(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncIndividualsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncIndividualsWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncIndividualsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncIndividualsWithStreamingResponse(self) def retrieve_many( diff --git a/src/finch/resources/hris/pay_statements.py b/src/finch/resources/hris/pay_statements.py index 0fa29199..818f4655 100644 --- a/src/finch/resources/hris/pay_statements.py +++ b/src/finch/resources/hris/pay_statements.py @@ -23,10 +23,21 @@ class PayStatements(SyncAPIResource): @cached_property def with_raw_response(self) -> PayStatementsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return PayStatementsWithRawResponse(self) @cached_property def with_streaming_response(self) -> PayStatementsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return PayStatementsWithStreamingResponse(self) def retrieve_many( @@ -74,10 +85,21 @@ def retrieve_many( class AsyncPayStatements(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncPayStatementsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncPayStatementsWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncPayStatementsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncPayStatementsWithStreamingResponse(self) def retrieve_many( diff --git a/src/finch/resources/hris/payments.py b/src/finch/resources/hris/payments.py index 8e27e735..9f7667eb 100644 --- a/src/finch/resources/hris/payments.py +++ b/src/finch/resources/hris/payments.py @@ -24,10 +24,21 @@ class Payments(SyncAPIResource): @cached_property def with_raw_response(self) -> PaymentsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return PaymentsWithRawResponse(self) @cached_property def with_streaming_response(self) -> PaymentsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return PaymentsWithStreamingResponse(self) def list( @@ -83,10 +94,21 @@ def list( class AsyncPayments(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncPaymentsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncPaymentsWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncPaymentsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncPaymentsWithStreamingResponse(self) def list( diff --git a/src/finch/resources/jobs/automated.py b/src/finch/resources/jobs/automated.py index 34cf152c..b8bcb702 100644 --- a/src/finch/resources/jobs/automated.py +++ b/src/finch/resources/jobs/automated.py @@ -27,10 +27,21 @@ class Automated(SyncAPIResource): @cached_property def with_raw_response(self) -> AutomatedWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AutomatedWithRawResponse(self) @cached_property def with_streaming_response(self) -> AutomatedWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AutomatedWithStreamingResponse(self) def create( @@ -164,10 +175,21 @@ def list( class AsyncAutomated(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncAutomatedWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncAutomatedWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncAutomatedWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncAutomatedWithStreamingResponse(self) async def create( diff --git a/src/finch/resources/jobs/jobs.py b/src/finch/resources/jobs/jobs.py index 950f977f..d6da244e 100644 --- a/src/finch/resources/jobs/jobs.py +++ b/src/finch/resources/jobs/jobs.py @@ -35,10 +35,21 @@ def manual(self) -> Manual: @cached_property def with_raw_response(self) -> JobsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return JobsWithRawResponse(self) @cached_property def with_streaming_response(self) -> JobsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return JobsWithStreamingResponse(self) @@ -53,10 +64,21 @@ def manual(self) -> AsyncManual: @cached_property def with_raw_response(self) -> AsyncJobsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncJobsWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncJobsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncJobsWithStreamingResponse(self) diff --git a/src/finch/resources/jobs/manual.py b/src/finch/resources/jobs/manual.py index 740131e2..bdc08576 100644 --- a/src/finch/resources/jobs/manual.py +++ b/src/finch/resources/jobs/manual.py @@ -18,10 +18,21 @@ class Manual(SyncAPIResource): @cached_property def with_raw_response(self) -> ManualWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return ManualWithRawResponse(self) @cached_property def with_streaming_response(self) -> ManualWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return ManualWithStreamingResponse(self) def retrieve( @@ -63,10 +74,21 @@ def retrieve( class AsyncManual(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncManualWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncManualWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncManualWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncManualWithStreamingResponse(self) async def retrieve( diff --git a/src/finch/resources/payroll/pay_groups.py b/src/finch/resources/payroll/pay_groups.py index edcf6e8d..5673be66 100644 --- a/src/finch/resources/payroll/pay_groups.py +++ b/src/finch/resources/payroll/pay_groups.py @@ -24,10 +24,21 @@ class PayGroups(SyncAPIResource): @cached_property def with_raw_response(self) -> PayGroupsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return PayGroupsWithRawResponse(self) @cached_property def with_streaming_response(self) -> PayGroupsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return PayGroupsWithStreamingResponse(self) def retrieve( @@ -110,10 +121,21 @@ def list( class AsyncPayGroups(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncPayGroupsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncPayGroupsWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncPayGroupsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncPayGroupsWithStreamingResponse(self) async def retrieve( diff --git a/src/finch/resources/payroll/payroll.py b/src/finch/resources/payroll/payroll.py index 01bebaa6..d84fb628 100644 --- a/src/finch/resources/payroll/payroll.py +++ b/src/finch/resources/payroll/payroll.py @@ -23,10 +23,21 @@ def pay_groups(self) -> PayGroups: @cached_property def with_raw_response(self) -> PayrollWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return PayrollWithRawResponse(self) @cached_property def with_streaming_response(self) -> PayrollWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return PayrollWithStreamingResponse(self) @@ -37,10 +48,21 @@ def pay_groups(self) -> AsyncPayGroups: @cached_property def with_raw_response(self) -> AsyncPayrollWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncPayrollWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncPayrollWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncPayrollWithStreamingResponse(self) diff --git a/src/finch/resources/providers.py b/src/finch/resources/providers.py index eabf68d7..bb26ce7d 100644 --- a/src/finch/resources/providers.py +++ b/src/finch/resources/providers.py @@ -19,10 +19,21 @@ class Providers(SyncAPIResource): @cached_property def with_raw_response(self) -> ProvidersWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return ProvidersWithRawResponse(self) @cached_property def with_streaming_response(self) -> ProvidersWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return ProvidersWithStreamingResponse(self) def list( @@ -49,10 +60,21 @@ def list( class AsyncProviders(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncProvidersWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncProvidersWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncProvidersWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncProvidersWithStreamingResponse(self) def list( diff --git a/src/finch/resources/request_forwarding.py b/src/finch/resources/request_forwarding.py index 9e1d314a..578f1f70 100644 --- a/src/finch/resources/request_forwarding.py +++ b/src/finch/resources/request_forwarding.py @@ -25,10 +25,21 @@ class RequestForwarding(SyncAPIResource): @cached_property def with_raw_response(self) -> RequestForwardingWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return RequestForwardingWithRawResponse(self) @cached_property def with_streaming_response(self) -> RequestForwardingWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return RequestForwardingWithStreamingResponse(self) def forward( @@ -101,10 +112,21 @@ def forward( class AsyncRequestForwarding(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncRequestForwardingWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncRequestForwardingWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncRequestForwardingWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncRequestForwardingWithStreamingResponse(self) async def forward( diff --git a/src/finch/resources/sandbox/company.py b/src/finch/resources/sandbox/company.py index c243bfef..12302429 100644 --- a/src/finch/resources/sandbox/company.py +++ b/src/finch/resources/sandbox/company.py @@ -26,10 +26,21 @@ class Company(SyncAPIResource): @cached_property def with_raw_response(self) -> CompanyWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return CompanyWithRawResponse(self) @cached_property def with_streaming_response(self) -> CompanyWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return CompanyWithStreamingResponse(self) def update( @@ -101,10 +112,21 @@ def update( class AsyncCompany(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncCompanyWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncCompanyWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncCompanyWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncCompanyWithStreamingResponse(self) async def update( diff --git a/src/finch/resources/sandbox/connections/accounts.py b/src/finch/resources/sandbox/connections/accounts.py index d7be2e90..8a1d088f 100644 --- a/src/finch/resources/sandbox/connections/accounts.py +++ b/src/finch/resources/sandbox/connections/accounts.py @@ -28,10 +28,21 @@ class Accounts(SyncAPIResource): @cached_property def with_raw_response(self) -> AccountsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AccountsWithRawResponse(self) @cached_property def with_streaming_response(self) -> AccountsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AccountsWithStreamingResponse(self) def create( @@ -120,10 +131,21 @@ def update( class AsyncAccounts(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncAccountsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncAccountsWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncAccountsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncAccountsWithStreamingResponse(self) async def create( diff --git a/src/finch/resources/sandbox/connections/connections.py b/src/finch/resources/sandbox/connections/connections.py index 9baae475..dbd2c146 100644 --- a/src/finch/resources/sandbox/connections/connections.py +++ b/src/finch/resources/sandbox/connections/connections.py @@ -38,10 +38,21 @@ def accounts(self) -> Accounts: @cached_property def with_raw_response(self) -> ConnectionsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return ConnectionsWithRawResponse(self) @cached_property def with_streaming_response(self) -> ConnectionsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return ConnectionsWithStreamingResponse(self) def create( @@ -101,10 +112,21 @@ def accounts(self) -> AsyncAccounts: @cached_property def with_raw_response(self) -> AsyncConnectionsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncConnectionsWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncConnectionsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncConnectionsWithStreamingResponse(self) async def create( diff --git a/src/finch/resources/sandbox/directory.py b/src/finch/resources/sandbox/directory.py index f6b414ad..0c3a1501 100644 --- a/src/finch/resources/sandbox/directory.py +++ b/src/finch/resources/sandbox/directory.py @@ -25,10 +25,21 @@ class Directory(SyncAPIResource): @cached_property def with_raw_response(self) -> DirectoryWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return DirectoryWithRawResponse(self) @cached_property def with_streaming_response(self) -> DirectoryWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return DirectoryWithStreamingResponse(self) def create( @@ -70,10 +81,21 @@ def create( class AsyncDirectory(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncDirectoryWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncDirectoryWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncDirectoryWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncDirectoryWithStreamingResponse(self) async def create( diff --git a/src/finch/resources/sandbox/employment.py b/src/finch/resources/sandbox/employment.py index 1e3b8c1a..e7993252 100644 --- a/src/finch/resources/sandbox/employment.py +++ b/src/finch/resources/sandbox/employment.py @@ -27,10 +27,21 @@ class Employment(SyncAPIResource): @cached_property def with_raw_response(self) -> EmploymentWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return EmploymentWithRawResponse(self) @cached_property def with_streaming_response(self) -> EmploymentWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return EmploymentWithStreamingResponse(self) def update( @@ -139,10 +150,21 @@ def update( class AsyncEmployment(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncEmploymentWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncEmploymentWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncEmploymentWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncEmploymentWithStreamingResponse(self) async def update( diff --git a/src/finch/resources/sandbox/individual.py b/src/finch/resources/sandbox/individual.py index d06155b6..a6825c69 100644 --- a/src/finch/resources/sandbox/individual.py +++ b/src/finch/resources/sandbox/individual.py @@ -27,10 +27,21 @@ class Individual(SyncAPIResource): @cached_property def with_raw_response(self) -> IndividualWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return IndividualWithRawResponse(self) @cached_property def with_streaming_response(self) -> IndividualWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return IndividualWithStreamingResponse(self) def update( @@ -134,10 +145,21 @@ def update( class AsyncIndividual(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncIndividualWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncIndividualWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncIndividualWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncIndividualWithStreamingResponse(self) async def update( diff --git a/src/finch/resources/sandbox/jobs/configuration.py b/src/finch/resources/sandbox/jobs/configuration.py index 8aae6f08..6f2b1dd6 100644 --- a/src/finch/resources/sandbox/jobs/configuration.py +++ b/src/finch/resources/sandbox/jobs/configuration.py @@ -26,10 +26,21 @@ class Configuration(SyncAPIResource): @cached_property def with_raw_response(self) -> ConfigurationWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return ConfigurationWithRawResponse(self) @cached_property def with_streaming_response(self) -> ConfigurationWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return ConfigurationWithStreamingResponse(self) def retrieve( @@ -94,10 +105,21 @@ def update( class AsyncConfiguration(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncConfigurationWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncConfigurationWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncConfigurationWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncConfigurationWithStreamingResponse(self) async def retrieve( diff --git a/src/finch/resources/sandbox/jobs/jobs.py b/src/finch/resources/sandbox/jobs/jobs.py index b8c904a7..2a94fa45 100644 --- a/src/finch/resources/sandbox/jobs/jobs.py +++ b/src/finch/resources/sandbox/jobs/jobs.py @@ -37,10 +37,21 @@ def configuration(self) -> Configuration: @cached_property def with_raw_response(self) -> JobsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return JobsWithRawResponse(self) @cached_property def with_streaming_response(self) -> JobsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return JobsWithStreamingResponse(self) def create( @@ -86,10 +97,21 @@ def configuration(self) -> AsyncConfiguration: @cached_property def with_raw_response(self) -> AsyncJobsWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncJobsWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncJobsWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncJobsWithStreamingResponse(self) async def create( diff --git a/src/finch/resources/sandbox/payment.py b/src/finch/resources/sandbox/payment.py index 33b62542..6cd96253 100644 --- a/src/finch/resources/sandbox/payment.py +++ b/src/finch/resources/sandbox/payment.py @@ -25,10 +25,21 @@ class Payment(SyncAPIResource): @cached_property def with_raw_response(self) -> PaymentWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return PaymentWithRawResponse(self) @cached_property def with_streaming_response(self) -> PaymentWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return PaymentWithStreamingResponse(self) def create( @@ -76,10 +87,21 @@ def create( class AsyncPayment(AsyncAPIResource): @cached_property def with_raw_response(self) -> AsyncPaymentWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncPaymentWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncPaymentWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncPaymentWithStreamingResponse(self) async def create( diff --git a/src/finch/resources/sandbox/sandbox.py b/src/finch/resources/sandbox/sandbox.py index d4b5a8d2..33f73435 100644 --- a/src/finch/resources/sandbox/sandbox.py +++ b/src/finch/resources/sandbox/sandbox.py @@ -97,10 +97,21 @@ def jobs(self) -> Jobs: @cached_property def with_raw_response(self) -> SandboxWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return SandboxWithRawResponse(self) @cached_property def with_streaming_response(self) -> SandboxWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return SandboxWithStreamingResponse(self) @@ -135,10 +146,21 @@ def jobs(self) -> AsyncJobs: @cached_property def with_raw_response(self) -> AsyncSandboxWithRawResponse: + """ + 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/Finch-API/finch-api-python#accessing-raw-response-data-eg-headers + """ return AsyncSandboxWithRawResponse(self) @cached_property def with_streaming_response(self) -> AsyncSandboxWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Finch-API/finch-api-python#with_streaming_response + """ return AsyncSandboxWithStreamingResponse(self)