From b93064efd7776bafcede0fa0fc3bd82ea2673496 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Apr 2026 00:33:08 +0000 Subject: [PATCH 1/8] codegen metadata --- .stats.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.stats.yml b/.stats.yml index 5eb6287..b114f5a 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 18 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openregister%2Fopenregister-9a16d26d3d15e7f3480c3698acdd309afb81e326d05aafde1918722e6dfb56bb.yml -openapi_spec_hash: 55cb8744ec3e7eb76956e0034569e417 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openregister%2Fopenregister-5a51b4240084d1d903ee77093e89f019c17f1b766f23674361e03254b8819d2a.yml +openapi_spec_hash: 3ad1e40af8a189b7c6c747794f280f24 config_hash: 37583af6a46faf905309043dc42cad52 From 264ef57eab2f1eba138decaeb5dc5547d93e677d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 15 Apr 2026 00:37:18 +0000 Subject: [PATCH 2/8] feat(api): transparenzregister endpoints --- .stats.yml | 4 +- api.md | 19 ++ src/openregister/_client.py | 42 ++- src/openregister/resources/__init__.py | 14 + .../resources/transparenzregister/__init__.py | 33 +++ .../resources/transparenzregister/request.py | 274 ++++++++++++++++++ .../transparenzregister.py | 238 +++++++++++++++ src/openregister/types/__init__.py | 3 + .../types/transparenzregister/__init__.py | 7 + .../request_create_v1_params.py | 19 ++ .../request_create_v1_response.py | 12 + .../request_get_v1_response.py | 45 +++ ...arenzregister_set_credentials_v1_params.py | 26 ++ .../api_resources/test_transparenzregister.py | 116 ++++++++ .../transparenzregister/__init__.py | 1 + .../transparenzregister/test_request.py | 185 ++++++++++++ 16 files changed, 1035 insertions(+), 3 deletions(-) create mode 100644 src/openregister/resources/transparenzregister/__init__.py create mode 100644 src/openregister/resources/transparenzregister/request.py create mode 100644 src/openregister/resources/transparenzregister/transparenzregister.py create mode 100644 src/openregister/types/transparenzregister/__init__.py create mode 100644 src/openregister/types/transparenzregister/request_create_v1_params.py create mode 100644 src/openregister/types/transparenzregister/request_create_v1_response.py create mode 100644 src/openregister/types/transparenzregister/request_get_v1_response.py create mode 100644 src/openregister/types/transparenzregister_set_credentials_v1_params.py create mode 100644 tests/api_resources/test_transparenzregister.py create mode 100644 tests/api_resources/transparenzregister/__init__.py create mode 100644 tests/api_resources/transparenzregister/test_request.py diff --git a/.stats.yml b/.stats.yml index b114f5a..1da96af 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 18 +configured_endpoints: 21 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openregister%2Fopenregister-5a51b4240084d1d903ee77093e89f019c17f1b766f23674361e03254b8819d2a.yml openapi_spec_hash: 3ad1e40af8a189b7c6c747794f280f24 -config_hash: 37583af6a46faf905309043dc42cad52 +config_hash: 5bfcfda26d3c6818d4f965aa201ed985 diff --git a/api.md b/api.md index aad2230..02be08c 100644 --- a/api.md +++ b/api.md @@ -105,3 +105,22 @@ Methods: - client.monitor.create(\*\*params) -> MonitorCreateResponse - client.monitor.list() -> MonitorListResponse - client.monitor.delete(entity_id) -> None + +# Transparenzregister + +Methods: + +- client.transparenzregister.set_credentials_v1(\*\*params) -> None + +## Request + +Types: + +```python +from openregister.types.transparenzregister import RequestCreateV1Response, RequestGetV1Response +``` + +Methods: + +- client.transparenzregister.request.create_v1(\*\*params) -> RequestCreateV1Response +- client.transparenzregister.request.get_v1(request_id) -> RequestGetV1Response diff --git a/src/openregister/_client.py b/src/openregister/_client.py index 42b242a..8369643 100644 --- a/src/openregister/_client.py +++ b/src/openregister/_client.py @@ -31,12 +31,16 @@ ) if TYPE_CHECKING: - from .resources import person, search, company, monitor, document + from .resources import person, search, company, monitor, document, transparenzregister from .resources.person import PersonResource, AsyncPersonResource from .resources.search import SearchResource, AsyncSearchResource from .resources.company import CompanyResource, AsyncCompanyResource from .resources.monitor import MonitorResource, AsyncMonitorResource from .resources.document import DocumentResource, AsyncDocumentResource + from .resources.transparenzregister.transparenzregister import ( + TransparenzregisterResource, + AsyncTransparenzregisterResource, + ) __all__ = [ "Timeout", @@ -135,6 +139,12 @@ def monitor(self) -> MonitorResource: return MonitorResource(self) + @cached_property + def transparenzregister(self) -> TransparenzregisterResource: + from .resources.transparenzregister import TransparenzregisterResource + + return TransparenzregisterResource(self) + @cached_property def with_raw_response(self) -> OpenregisterWithRawResponse: return OpenregisterWithRawResponse(self) @@ -333,6 +343,12 @@ def monitor(self) -> AsyncMonitorResource: return AsyncMonitorResource(self) + @cached_property + def transparenzregister(self) -> AsyncTransparenzregisterResource: + from .resources.transparenzregister import AsyncTransparenzregisterResource + + return AsyncTransparenzregisterResource(self) + @cached_property def with_raw_response(self) -> AsyncOpenregisterWithRawResponse: return AsyncOpenregisterWithRawResponse(self) @@ -482,6 +498,12 @@ def monitor(self) -> monitor.MonitorResourceWithRawResponse: return MonitorResourceWithRawResponse(self._client.monitor) + @cached_property + def transparenzregister(self) -> transparenzregister.TransparenzregisterResourceWithRawResponse: + from .resources.transparenzregister import TransparenzregisterResourceWithRawResponse + + return TransparenzregisterResourceWithRawResponse(self._client.transparenzregister) + class AsyncOpenregisterWithRawResponse: _client: AsyncOpenregister @@ -519,6 +541,12 @@ def monitor(self) -> monitor.AsyncMonitorResourceWithRawResponse: return AsyncMonitorResourceWithRawResponse(self._client.monitor) + @cached_property + def transparenzregister(self) -> transparenzregister.AsyncTransparenzregisterResourceWithRawResponse: + from .resources.transparenzregister import AsyncTransparenzregisterResourceWithRawResponse + + return AsyncTransparenzregisterResourceWithRawResponse(self._client.transparenzregister) + class OpenregisterWithStreamedResponse: _client: Openregister @@ -556,6 +584,12 @@ def monitor(self) -> monitor.MonitorResourceWithStreamingResponse: return MonitorResourceWithStreamingResponse(self._client.monitor) + @cached_property + def transparenzregister(self) -> transparenzregister.TransparenzregisterResourceWithStreamingResponse: + from .resources.transparenzregister import TransparenzregisterResourceWithStreamingResponse + + return TransparenzregisterResourceWithStreamingResponse(self._client.transparenzregister) + class AsyncOpenregisterWithStreamedResponse: _client: AsyncOpenregister @@ -593,6 +627,12 @@ def monitor(self) -> monitor.AsyncMonitorResourceWithStreamingResponse: return AsyncMonitorResourceWithStreamingResponse(self._client.monitor) + @cached_property + def transparenzregister(self) -> transparenzregister.AsyncTransparenzregisterResourceWithStreamingResponse: + from .resources.transparenzregister import AsyncTransparenzregisterResourceWithStreamingResponse + + return AsyncTransparenzregisterResourceWithStreamingResponse(self._client.transparenzregister) + Client = Openregister diff --git a/src/openregister/resources/__init__.py b/src/openregister/resources/__init__.py index 273d61e..9ef628c 100644 --- a/src/openregister/resources/__init__.py +++ b/src/openregister/resources/__init__.py @@ -40,6 +40,14 @@ DocumentResourceWithStreamingResponse, AsyncDocumentResourceWithStreamingResponse, ) +from .transparenzregister import ( + TransparenzregisterResource, + AsyncTransparenzregisterResource, + TransparenzregisterResourceWithRawResponse, + AsyncTransparenzregisterResourceWithRawResponse, + TransparenzregisterResourceWithStreamingResponse, + AsyncTransparenzregisterResourceWithStreamingResponse, +) __all__ = [ "SearchResource", @@ -72,4 +80,10 @@ "AsyncMonitorResourceWithRawResponse", "MonitorResourceWithStreamingResponse", "AsyncMonitorResourceWithStreamingResponse", + "TransparenzregisterResource", + "AsyncTransparenzregisterResource", + "TransparenzregisterResourceWithRawResponse", + "AsyncTransparenzregisterResourceWithRawResponse", + "TransparenzregisterResourceWithStreamingResponse", + "AsyncTransparenzregisterResourceWithStreamingResponse", ] diff --git a/src/openregister/resources/transparenzregister/__init__.py b/src/openregister/resources/transparenzregister/__init__.py new file mode 100644 index 0000000..7bd1047 --- /dev/null +++ b/src/openregister/resources/transparenzregister/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .request import ( + RequestResource, + AsyncRequestResource, + RequestResourceWithRawResponse, + AsyncRequestResourceWithRawResponse, + RequestResourceWithStreamingResponse, + AsyncRequestResourceWithStreamingResponse, +) +from .transparenzregister import ( + TransparenzregisterResource, + AsyncTransparenzregisterResource, + TransparenzregisterResourceWithRawResponse, + AsyncTransparenzregisterResourceWithRawResponse, + TransparenzregisterResourceWithStreamingResponse, + AsyncTransparenzregisterResourceWithStreamingResponse, +) + +__all__ = [ + "RequestResource", + "AsyncRequestResource", + "RequestResourceWithRawResponse", + "AsyncRequestResourceWithRawResponse", + "RequestResourceWithStreamingResponse", + "AsyncRequestResourceWithStreamingResponse", + "TransparenzregisterResource", + "AsyncTransparenzregisterResource", + "TransparenzregisterResourceWithRawResponse", + "AsyncTransparenzregisterResourceWithRawResponse", + "TransparenzregisterResourceWithStreamingResponse", + "AsyncTransparenzregisterResourceWithStreamingResponse", +] diff --git a/src/openregister/resources/transparenzregister/request.py b/src/openregister/resources/transparenzregister/request.py new file mode 100644 index 0000000..91df747 --- /dev/null +++ b/src/openregister/resources/transparenzregister/request.py @@ -0,0 +1,274 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given +from ..._utils import path_template, maybe_transform, strip_not_given, async_maybe_transform +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..._base_client import make_request_options +from ...types.transparenzregister import request_create_v1_params +from ...types.transparenzregister.request_get_v1_response import RequestGetV1Response +from ...types.transparenzregister.request_create_v1_response import RequestCreateV1Response + +__all__ = ["RequestResource", "AsyncRequestResource"] + + +class RequestResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> RequestResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/oregister/openregister-python#accessing-raw-response-data-eg-headers + """ + return RequestResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> RequestResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/oregister/openregister-python#with_streaming_response + """ + return RequestResourceWithStreamingResponse(self) + + def create_v1( + self, + *, + company_id: str | Omit = omit, + x_credential_label: str | Omit = omit, + # 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, + ) -> RequestCreateV1Response: + """Submit a Transparenzregister request for a company using its company ID. + + This + endpoint will initiate the Transparenzregister request process and return a + request ID for tracking. + + Args: + company_id: Unique company identifier. Required unless using X-Credential-Label=test. + Example: DE-HRB-F1103-267645 + + 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 + """ + extra_headers = {**strip_not_given({"X-Credential-Label": x_credential_label}), **(extra_headers or {})} + return self._post( + "/v1/transparenzregister/request", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform({"company_id": company_id}, request_create_v1_params.RequestCreateV1Params), + ), + cast_to=RequestCreateV1Response, + ) + + def get_v1( + self, + request_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, + ) -> RequestGetV1Response: + """Get the results of a Transparenzregister request. + + This endpoint handles all + internal complexity including polling request status, selecting all available + documents, creating Transparenzregister baskets, and returning download URLs + when ready. If the request is still processing, it will return a pending status. + + 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 request_id: + raise ValueError(f"Expected a non-empty value for `request_id` but received {request_id!r}") + return self._get( + path_template("/v1/transparenzregister/request/{request_id}", request_id=request_id), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=RequestGetV1Response, + ) + + +class AsyncRequestResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncRequestResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/oregister/openregister-python#accessing-raw-response-data-eg-headers + """ + return AsyncRequestResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncRequestResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/oregister/openregister-python#with_streaming_response + """ + return AsyncRequestResourceWithStreamingResponse(self) + + async def create_v1( + self, + *, + company_id: str | Omit = omit, + x_credential_label: str | Omit = omit, + # 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, + ) -> RequestCreateV1Response: + """Submit a Transparenzregister request for a company using its company ID. + + This + endpoint will initiate the Transparenzregister request process and return a + request ID for tracking. + + Args: + company_id: Unique company identifier. Required unless using X-Credential-Label=test. + Example: DE-HRB-F1103-267645 + + 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 + """ + extra_headers = {**strip_not_given({"X-Credential-Label": x_credential_label}), **(extra_headers or {})} + return await self._post( + "/v1/transparenzregister/request", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + {"company_id": company_id}, request_create_v1_params.RequestCreateV1Params + ), + ), + cast_to=RequestCreateV1Response, + ) + + async def get_v1( + self, + request_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, + ) -> RequestGetV1Response: + """Get the results of a Transparenzregister request. + + This endpoint handles all + internal complexity including polling request status, selecting all available + documents, creating Transparenzregister baskets, and returning download URLs + when ready. If the request is still processing, it will return a pending status. + + 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 request_id: + raise ValueError(f"Expected a non-empty value for `request_id` but received {request_id!r}") + return await self._get( + path_template("/v1/transparenzregister/request/{request_id}", request_id=request_id), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=RequestGetV1Response, + ) + + +class RequestResourceWithRawResponse: + def __init__(self, request: RequestResource) -> None: + self._request = request + + self.create_v1 = to_raw_response_wrapper( + request.create_v1, + ) + self.get_v1 = to_raw_response_wrapper( + request.get_v1, + ) + + +class AsyncRequestResourceWithRawResponse: + def __init__(self, request: AsyncRequestResource) -> None: + self._request = request + + self.create_v1 = async_to_raw_response_wrapper( + request.create_v1, + ) + self.get_v1 = async_to_raw_response_wrapper( + request.get_v1, + ) + + +class RequestResourceWithStreamingResponse: + def __init__(self, request: RequestResource) -> None: + self._request = request + + self.create_v1 = to_streamed_response_wrapper( + request.create_v1, + ) + self.get_v1 = to_streamed_response_wrapper( + request.get_v1, + ) + + +class AsyncRequestResourceWithStreamingResponse: + def __init__(self, request: AsyncRequestResource) -> None: + self._request = request + + self.create_v1 = async_to_streamed_response_wrapper( + request.create_v1, + ) + self.get_v1 = async_to_streamed_response_wrapper( + request.get_v1, + ) diff --git a/src/openregister/resources/transparenzregister/transparenzregister.py b/src/openregister/resources/transparenzregister/transparenzregister.py new file mode 100644 index 0000000..4c9642e --- /dev/null +++ b/src/openregister/resources/transparenzregister/transparenzregister.py @@ -0,0 +1,238 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ...types import transparenzregister_set_credentials_v1_params +from .request import ( + RequestResource, + AsyncRequestResource, + RequestResourceWithRawResponse, + AsyncRequestResourceWithRawResponse, + RequestResourceWithStreamingResponse, + AsyncRequestResourceWithStreamingResponse, +) +from ..._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given +from ..._utils import maybe_transform, async_maybe_transform +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..._base_client import make_request_options + +__all__ = ["TransparenzregisterResource", "AsyncTransparenzregisterResource"] + + +class TransparenzregisterResource(SyncAPIResource): + @cached_property + def request(self) -> RequestResource: + return RequestResource(self._client) + + @cached_property + def with_raw_response(self) -> TransparenzregisterResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/oregister/openregister-python#accessing-raw-response-data-eg-headers + """ + return TransparenzregisterResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> TransparenzregisterResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/oregister/openregister-python#with_streaming_response + """ + return TransparenzregisterResourceWithStreamingResponse(self) + + def set_credentials_v1( + self, + *, + password: str, + username: str, + credential_label: str | Omit = omit, + # 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: + """ + Store username and password credentials for accessing the Transparenzregister + API. These credentials will be used for subsequent requests to retrieve company + documents. + + Args: + password: Password for Transparenzregister API access. + + username: + Username for Transparenzregister API access. Example: + "testnutzer-eis@transparenzregister.de" + + credential_label: Label to identify this set of credentials. Allows storing multiple + Transparenzregister credentials per user (e.g., for different accounts or + clients). Defaults to 'default' if not provided. Example: "client_a" + + 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 + """ + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return self._post( + "/v1/transparenzregister/credentials", + body=maybe_transform( + { + "password": password, + "username": username, + "credential_label": credential_label, + }, + transparenzregister_set_credentials_v1_params.TransparenzregisterSetCredentialsV1Params, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + + +class AsyncTransparenzregisterResource(AsyncAPIResource): + @cached_property + def request(self) -> AsyncRequestResource: + return AsyncRequestResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncTransparenzregisterResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/oregister/openregister-python#accessing-raw-response-data-eg-headers + """ + return AsyncTransparenzregisterResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncTransparenzregisterResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/oregister/openregister-python#with_streaming_response + """ + return AsyncTransparenzregisterResourceWithStreamingResponse(self) + + async def set_credentials_v1( + self, + *, + password: str, + username: str, + credential_label: str | Omit = omit, + # 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: + """ + Store username and password credentials for accessing the Transparenzregister + API. These credentials will be used for subsequent requests to retrieve company + documents. + + Args: + password: Password for Transparenzregister API access. + + username: + Username for Transparenzregister API access. Example: + "testnutzer-eis@transparenzregister.de" + + credential_label: Label to identify this set of credentials. Allows storing multiple + Transparenzregister credentials per user (e.g., for different accounts or + clients). Defaults to 'default' if not provided. Example: "client_a" + + 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 + """ + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return await self._post( + "/v1/transparenzregister/credentials", + body=await async_maybe_transform( + { + "password": password, + "username": username, + "credential_label": credential_label, + }, + transparenzregister_set_credentials_v1_params.TransparenzregisterSetCredentialsV1Params, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + + +class TransparenzregisterResourceWithRawResponse: + def __init__(self, transparenzregister: TransparenzregisterResource) -> None: + self._transparenzregister = transparenzregister + + self.set_credentials_v1 = to_raw_response_wrapper( + transparenzregister.set_credentials_v1, + ) + + @cached_property + def request(self) -> RequestResourceWithRawResponse: + return RequestResourceWithRawResponse(self._transparenzregister.request) + + +class AsyncTransparenzregisterResourceWithRawResponse: + def __init__(self, transparenzregister: AsyncTransparenzregisterResource) -> None: + self._transparenzregister = transparenzregister + + self.set_credentials_v1 = async_to_raw_response_wrapper( + transparenzregister.set_credentials_v1, + ) + + @cached_property + def request(self) -> AsyncRequestResourceWithRawResponse: + return AsyncRequestResourceWithRawResponse(self._transparenzregister.request) + + +class TransparenzregisterResourceWithStreamingResponse: + def __init__(self, transparenzregister: TransparenzregisterResource) -> None: + self._transparenzregister = transparenzregister + + self.set_credentials_v1 = to_streamed_response_wrapper( + transparenzregister.set_credentials_v1, + ) + + @cached_property + def request(self) -> RequestResourceWithStreamingResponse: + return RequestResourceWithStreamingResponse(self._transparenzregister.request) + + +class AsyncTransparenzregisterResourceWithStreamingResponse: + def __init__(self, transparenzregister: AsyncTransparenzregisterResource) -> None: + self._transparenzregister = transparenzregister + + self.set_credentials_v1 = async_to_streamed_response_wrapper( + transparenzregister.set_credentials_v1, + ) + + @cached_property + def request(self) -> AsyncRequestResourceWithStreamingResponse: + return AsyncRequestResourceWithStreamingResponse(self._transparenzregister.request) diff --git a/src/openregister/types/__init__.py b/src/openregister/types/__init__.py index 0327aec..ad39104 100644 --- a/src/openregister/types/__init__.py +++ b/src/openregister/types/__init__.py @@ -57,6 +57,9 @@ from .search_autocomplete_companies_v1_response import ( SearchAutocompleteCompaniesV1Response as SearchAutocompleteCompaniesV1Response, ) +from .transparenzregister_set_credentials_v1_params import ( + TransparenzregisterSetCredentialsV1Params as TransparenzregisterSetCredentialsV1Params, +) # Rebuild cyclical models only after all modules are imported. # This ensures that, when building the deferred (due to cyclical references) model schema, diff --git a/src/openregister/types/transparenzregister/__init__.py b/src/openregister/types/transparenzregister/__init__.py new file mode 100644 index 0000000..72be816 --- /dev/null +++ b/src/openregister/types/transparenzregister/__init__.py @@ -0,0 +1,7 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from .request_get_v1_response import RequestGetV1Response as RequestGetV1Response +from .request_create_v1_params import RequestCreateV1Params as RequestCreateV1Params +from .request_create_v1_response import RequestCreateV1Response as RequestCreateV1Response diff --git a/src/openregister/types/transparenzregister/request_create_v1_params.py b/src/openregister/types/transparenzregister/request_create_v1_params.py new file mode 100644 index 0000000..f046d0f --- /dev/null +++ b/src/openregister/types/transparenzregister/request_create_v1_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_extensions import Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["RequestCreateV1Params"] + + +class RequestCreateV1Params(TypedDict, total=False): + company_id: str + """Unique company identifier. + + Required unless using X-Credential-Label=test. Example: DE-HRB-F1103-267645 + """ + + x_credential_label: Annotated[str, PropertyInfo(alias="X-Credential-Label")] diff --git a/src/openregister/types/transparenzregister/request_create_v1_response.py b/src/openregister/types/transparenzregister/request_create_v1_response.py new file mode 100644 index 0000000..9cb2f32 --- /dev/null +++ b/src/openregister/types/transparenzregister/request_create_v1_response.py @@ -0,0 +1,12 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from ..._models import BaseModel + +__all__ = ["RequestCreateV1Response"] + + +class RequestCreateV1Response(BaseModel): + """Response from submitting a document request.""" + + request_id: str + """Request ID for tracking the document request. Example: "req_12345678" """ diff --git a/src/openregister/types/transparenzregister/request_get_v1_response.py b/src/openregister/types/transparenzregister/request_get_v1_response.py new file mode 100644 index 0000000..b4db87a --- /dev/null +++ b/src/openregister/types/transparenzregister/request_get_v1_response.py @@ -0,0 +1,45 @@ +# 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__ = ["RequestGetV1Response", "DownloadURL"] + + +class DownloadURL(BaseModel): + """Download URL for a document with format information.""" + + document_id: str + """Stable UUID for this document.""" + + filename: str + """ + Suggested filename for the download. Example: "registerauszug_company_12345.pdf" + """ + + format: str + """Format of the downloadable document. Example: "xml", "pdf", "json" """ + + url: str + """ + Download URL for the document. Example: + "https://api.example.com/download/abc123" + """ + + +class RequestGetV1Response(BaseModel): + """ + Response containing document request results and download URLs. + All internal complexity (document IDs, baskets, polling) is handled automatically. + """ + + request_id: str + """Request ID that was used to submit the request. Example: "req_12345678" """ + + status: Literal["completed", "processing", "failed"] + """Status of the Transparenzregister request.""" + + download_urls: Optional[List[DownloadURL]] = None + """URLs for downloading all available documents.""" diff --git a/src/openregister/types/transparenzregister_set_credentials_v1_params.py b/src/openregister/types/transparenzregister_set_credentials_v1_params.py new file mode 100644 index 0000000..d90b764 --- /dev/null +++ b/src/openregister/types/transparenzregister_set_credentials_v1_params.py @@ -0,0 +1,26 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["TransparenzregisterSetCredentialsV1Params"] + + +class TransparenzregisterSetCredentialsV1Params(TypedDict, total=False): + password: Required[str] + """Password for Transparenzregister API access.""" + + username: Required[str] + """ + Username for Transparenzregister API access. Example: + "testnutzer-eis@transparenzregister.de" + """ + + credential_label: str + """Label to identify this set of credentials. + + Allows storing multiple Transparenzregister credentials per user (e.g., for + different accounts or clients). Defaults to 'default' if not provided. Example: + "client_a" + """ diff --git a/tests/api_resources/test_transparenzregister.py b/tests/api_resources/test_transparenzregister.py new file mode 100644 index 0000000..de8b7f4 --- /dev/null +++ b/tests/api_resources/test_transparenzregister.py @@ -0,0 +1,116 @@ +# 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 openregister import Openregister, AsyncOpenregister + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestTransparenzregister: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_set_credentials_v1(self, client: Openregister) -> None: + transparenzregister = client.transparenzregister.set_credentials_v1( + password="password", + username="username", + ) + assert transparenzregister is None + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_set_credentials_v1_with_all_params(self, client: Openregister) -> None: + transparenzregister = client.transparenzregister.set_credentials_v1( + password="password", + username="username", + credential_label="credential_label", + ) + assert transparenzregister is None + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_set_credentials_v1(self, client: Openregister) -> None: + response = client.transparenzregister.with_raw_response.set_credentials_v1( + password="password", + username="username", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + transparenzregister = response.parse() + assert transparenzregister is None + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_set_credentials_v1(self, client: Openregister) -> None: + with client.transparenzregister.with_streaming_response.set_credentials_v1( + password="password", + username="username", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + transparenzregister = response.parse() + assert transparenzregister is None + + assert cast(Any, response.is_closed) is True + + +class TestAsyncTransparenzregister: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_set_credentials_v1(self, async_client: AsyncOpenregister) -> None: + transparenzregister = await async_client.transparenzregister.set_credentials_v1( + password="password", + username="username", + ) + assert transparenzregister is None + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_set_credentials_v1_with_all_params(self, async_client: AsyncOpenregister) -> None: + transparenzregister = await async_client.transparenzregister.set_credentials_v1( + password="password", + username="username", + credential_label="credential_label", + ) + assert transparenzregister is None + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_set_credentials_v1(self, async_client: AsyncOpenregister) -> None: + response = await async_client.transparenzregister.with_raw_response.set_credentials_v1( + password="password", + username="username", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + transparenzregister = await response.parse() + assert transparenzregister is None + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_set_credentials_v1(self, async_client: AsyncOpenregister) -> None: + async with async_client.transparenzregister.with_streaming_response.set_credentials_v1( + password="password", + username="username", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + transparenzregister = await response.parse() + assert transparenzregister is None + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/transparenzregister/__init__.py b/tests/api_resources/transparenzregister/__init__.py new file mode 100644 index 0000000..fd8019a --- /dev/null +++ b/tests/api_resources/transparenzregister/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/transparenzregister/test_request.py b/tests/api_resources/transparenzregister/test_request.py new file mode 100644 index 0000000..0aa9f6c --- /dev/null +++ b/tests/api_resources/transparenzregister/test_request.py @@ -0,0 +1,185 @@ +# 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 tests.utils import assert_matches_type +from openregister import Openregister, AsyncOpenregister +from openregister.types.transparenzregister import ( + RequestGetV1Response, + RequestCreateV1Response, +) + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestRequest: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_v1(self, client: Openregister) -> None: + request = client.transparenzregister.request.create_v1() + assert_matches_type(RequestCreateV1Response, request, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_v1_with_all_params(self, client: Openregister) -> None: + request = client.transparenzregister.request.create_v1( + company_id="company_id", + x_credential_label="X-Credential-Label", + ) + assert_matches_type(RequestCreateV1Response, request, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_v1(self, client: Openregister) -> None: + response = client.transparenzregister.request.with_raw_response.create_v1() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + request = response.parse() + assert_matches_type(RequestCreateV1Response, request, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_v1(self, client: Openregister) -> None: + with client.transparenzregister.request.with_streaming_response.create_v1() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + request = response.parse() + assert_matches_type(RequestCreateV1Response, request, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_get_v1(self, client: Openregister) -> None: + request = client.transparenzregister.request.get_v1( + "request_id", + ) + assert_matches_type(RequestGetV1Response, request, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_get_v1(self, client: Openregister) -> None: + response = client.transparenzregister.request.with_raw_response.get_v1( + "request_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + request = response.parse() + assert_matches_type(RequestGetV1Response, request, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_get_v1(self, client: Openregister) -> None: + with client.transparenzregister.request.with_streaming_response.get_v1( + "request_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + request = response.parse() + assert_matches_type(RequestGetV1Response, request, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_path_params_get_v1(self, client: Openregister) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `request_id` but received ''"): + client.transparenzregister.request.with_raw_response.get_v1( + "", + ) + + +class TestAsyncRequest: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_v1(self, async_client: AsyncOpenregister) -> None: + request = await async_client.transparenzregister.request.create_v1() + assert_matches_type(RequestCreateV1Response, request, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_v1_with_all_params(self, async_client: AsyncOpenregister) -> None: + request = await async_client.transparenzregister.request.create_v1( + company_id="company_id", + x_credential_label="X-Credential-Label", + ) + assert_matches_type(RequestCreateV1Response, request, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_v1(self, async_client: AsyncOpenregister) -> None: + response = await async_client.transparenzregister.request.with_raw_response.create_v1() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + request = await response.parse() + assert_matches_type(RequestCreateV1Response, request, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_v1(self, async_client: AsyncOpenregister) -> None: + async with async_client.transparenzregister.request.with_streaming_response.create_v1() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + request = await response.parse() + assert_matches_type(RequestCreateV1Response, request, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_get_v1(self, async_client: AsyncOpenregister) -> None: + request = await async_client.transparenzregister.request.get_v1( + "request_id", + ) + assert_matches_type(RequestGetV1Response, request, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_get_v1(self, async_client: AsyncOpenregister) -> None: + response = await async_client.transparenzregister.request.with_raw_response.get_v1( + "request_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + request = await response.parse() + assert_matches_type(RequestGetV1Response, request, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_get_v1(self, async_client: AsyncOpenregister) -> None: + async with async_client.transparenzregister.request.with_streaming_response.get_v1( + "request_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + request = await response.parse() + assert_matches_type(RequestGetV1Response, request, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_path_params_get_v1(self, async_client: AsyncOpenregister) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `request_id` but received ''"): + await async_client.transparenzregister.request.with_raw_response.get_v1( + "", + ) From cc3039cfe06010b597aeb5a227ae3f440f47e44b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Apr 2026 15:54:25 +0000 Subject: [PATCH 3/8] feat(api): transparenzregister --- .stats.yml | 6 +- api.md | 15 +- src/openregister/_client.py | 5 +- .../transparenzregister.py | 80 ++--- .../resources/transparenzregister/__init__.py | 33 --- .../resources/transparenzregister/request.py | 274 ------------------ .../types/transparenzregister/__init__.py | 4 - .../request_create_v1_params.py | 19 -- .../request_create_v1_response.py | 12 - .../request_get_v1_response.py | 45 --- ...arenzregister_set_credentials_v1_params.py | 12 +- .../api_resources/test_transparenzregister.py | 4 +- .../transparenzregister/__init__.py | 1 - .../transparenzregister/test_request.py | 185 ------------ 14 files changed, 37 insertions(+), 658 deletions(-) rename src/openregister/resources/{transparenzregister => }/transparenzregister.py (74%) delete mode 100644 src/openregister/resources/transparenzregister/__init__.py delete mode 100644 src/openregister/resources/transparenzregister/request.py delete mode 100644 src/openregister/types/transparenzregister/request_create_v1_params.py delete mode 100644 src/openregister/types/transparenzregister/request_create_v1_response.py delete mode 100644 src/openregister/types/transparenzregister/request_get_v1_response.py delete mode 100644 tests/api_resources/transparenzregister/__init__.py delete mode 100644 tests/api_resources/transparenzregister/test_request.py diff --git a/.stats.yml b/.stats.yml index 1da96af..14e96d0 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 21 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openregister%2Fopenregister-5a51b4240084d1d903ee77093e89f019c17f1b766f23674361e03254b8819d2a.yml -openapi_spec_hash: 3ad1e40af8a189b7c6c747794f280f24 +configured_endpoints: 19 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openregister%2Fopenregister-2f01f03707acbaab4e506fdd89610379d13f8c086dce1dd8933feefd537c8b5c.yml +openapi_spec_hash: 9e3e745d3c5e9440f7500db48d5f3f67 config_hash: 5bfcfda26d3c6818d4f965aa201ed985 diff --git a/api.md b/api.md index 02be08c..e316eef 100644 --- a/api.md +++ b/api.md @@ -110,17 +110,4 @@ Methods: Methods: -- client.transparenzregister.set_credentials_v1(\*\*params) -> None - -## Request - -Types: - -```python -from openregister.types.transparenzregister import RequestCreateV1Response, RequestGetV1Response -``` - -Methods: - -- client.transparenzregister.request.create_v1(\*\*params) -> RequestCreateV1Response -- client.transparenzregister.request.get_v1(request_id) -> RequestGetV1Response +- client.transparenzregister.set_credentials_v1(\*\*params) -> None diff --git a/src/openregister/_client.py b/src/openregister/_client.py index 8369643..64cc58a 100644 --- a/src/openregister/_client.py +++ b/src/openregister/_client.py @@ -37,10 +37,7 @@ from .resources.company import CompanyResource, AsyncCompanyResource from .resources.monitor import MonitorResource, AsyncMonitorResource from .resources.document import DocumentResource, AsyncDocumentResource - from .resources.transparenzregister.transparenzregister import ( - TransparenzregisterResource, - AsyncTransparenzregisterResource, - ) + from .resources.transparenzregister import TransparenzregisterResource, AsyncTransparenzregisterResource __all__ = [ "Timeout", diff --git a/src/openregister/resources/transparenzregister/transparenzregister.py b/src/openregister/resources/transparenzregister.py similarity index 74% rename from src/openregister/resources/transparenzregister/transparenzregister.py rename to src/openregister/resources/transparenzregister.py index 4c9642e..d0f15df 100644 --- a/src/openregister/resources/transparenzregister/transparenzregister.py +++ b/src/openregister/resources/transparenzregister.py @@ -4,35 +4,23 @@ import httpx -from ...types import transparenzregister_set_credentials_v1_params -from .request import ( - RequestResource, - AsyncRequestResource, - RequestResourceWithRawResponse, - AsyncRequestResourceWithRawResponse, - RequestResourceWithStreamingResponse, - AsyncRequestResourceWithStreamingResponse, -) -from ..._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given -from ..._utils import maybe_transform, async_maybe_transform -from ..._compat import cached_property -from ..._resource import SyncAPIResource, AsyncAPIResource -from ..._response import ( +from ..types import transparenzregister_set_credentials_v1_params +from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given +from .._utils import maybe_transform, async_maybe_transform +from .._compat import cached_property +from .._resource import SyncAPIResource, AsyncAPIResource +from .._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from ..._base_client import make_request_options +from .._base_client import make_request_options __all__ = ["TransparenzregisterResource", "AsyncTransparenzregisterResource"] class TransparenzregisterResource(SyncAPIResource): - @cached_property - def request(self) -> RequestResource: - return RequestResource(self._client) - @cached_property def with_raw_response(self) -> TransparenzregisterResourceWithRawResponse: """ @@ -57,7 +45,7 @@ def set_credentials_v1( *, password: str, username: str, - credential_label: str | Omit = omit, + name: str | Omit = omit, # 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, @@ -68,18 +56,19 @@ def set_credentials_v1( """ Store username and password credentials for accessing the Transparenzregister API. These credentials will be used for subsequent requests to retrieve company - documents. + documents. Credential names are user-scoped; the reserved name `sandbox` cannot + be used. Credentials are validated against Transparenzregister before they are + persisted. Args: password: Password for Transparenzregister API access. - username: - Username for Transparenzregister API access. Example: - "testnutzer-eis@transparenzregister.de" + username: Username for Transparenzregister API access. Example: "compliance@example.com" - credential_label: Label to identify this set of credentials. Allows storing multiple + name: Name to identify this set of credentials. Allows storing multiple Transparenzregister credentials per user (e.g., for different accounts or - clients). Defaults to 'default' if not provided. Example: "client_a" + clients). Defaults to 'default' if not provided. Cannot be `sandbox` because + that name is reserved for test-mode extracts. Example: "client_a" extra_headers: Send extra headers @@ -96,7 +85,7 @@ def set_credentials_v1( { "password": password, "username": username, - "credential_label": credential_label, + "name": name, }, transparenzregister_set_credentials_v1_params.TransparenzregisterSetCredentialsV1Params, ), @@ -108,10 +97,6 @@ def set_credentials_v1( class AsyncTransparenzregisterResource(AsyncAPIResource): - @cached_property - def request(self) -> AsyncRequestResource: - return AsyncRequestResource(self._client) - @cached_property def with_raw_response(self) -> AsyncTransparenzregisterResourceWithRawResponse: """ @@ -136,7 +121,7 @@ async def set_credentials_v1( *, password: str, username: str, - credential_label: str | Omit = omit, + name: str | Omit = omit, # 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, @@ -147,18 +132,19 @@ async def set_credentials_v1( """ Store username and password credentials for accessing the Transparenzregister API. These credentials will be used for subsequent requests to retrieve company - documents. + documents. Credential names are user-scoped; the reserved name `sandbox` cannot + be used. Credentials are validated against Transparenzregister before they are + persisted. Args: password: Password for Transparenzregister API access. - username: - Username for Transparenzregister API access. Example: - "testnutzer-eis@transparenzregister.de" + username: Username for Transparenzregister API access. Example: "compliance@example.com" - credential_label: Label to identify this set of credentials. Allows storing multiple + name: Name to identify this set of credentials. Allows storing multiple Transparenzregister credentials per user (e.g., for different accounts or - clients). Defaults to 'default' if not provided. Example: "client_a" + clients). Defaults to 'default' if not provided. Cannot be `sandbox` because + that name is reserved for test-mode extracts. Example: "client_a" extra_headers: Send extra headers @@ -175,7 +161,7 @@ async def set_credentials_v1( { "password": password, "username": username, - "credential_label": credential_label, + "name": name, }, transparenzregister_set_credentials_v1_params.TransparenzregisterSetCredentialsV1Params, ), @@ -194,10 +180,6 @@ def __init__(self, transparenzregister: TransparenzregisterResource) -> None: transparenzregister.set_credentials_v1, ) - @cached_property - def request(self) -> RequestResourceWithRawResponse: - return RequestResourceWithRawResponse(self._transparenzregister.request) - class AsyncTransparenzregisterResourceWithRawResponse: def __init__(self, transparenzregister: AsyncTransparenzregisterResource) -> None: @@ -207,10 +189,6 @@ def __init__(self, transparenzregister: AsyncTransparenzregisterResource) -> Non transparenzregister.set_credentials_v1, ) - @cached_property - def request(self) -> AsyncRequestResourceWithRawResponse: - return AsyncRequestResourceWithRawResponse(self._transparenzregister.request) - class TransparenzregisterResourceWithStreamingResponse: def __init__(self, transparenzregister: TransparenzregisterResource) -> None: @@ -220,10 +198,6 @@ def __init__(self, transparenzregister: TransparenzregisterResource) -> None: transparenzregister.set_credentials_v1, ) - @cached_property - def request(self) -> RequestResourceWithStreamingResponse: - return RequestResourceWithStreamingResponse(self._transparenzregister.request) - class AsyncTransparenzregisterResourceWithStreamingResponse: def __init__(self, transparenzregister: AsyncTransparenzregisterResource) -> None: @@ -232,7 +206,3 @@ def __init__(self, transparenzregister: AsyncTransparenzregisterResource) -> Non self.set_credentials_v1 = async_to_streamed_response_wrapper( transparenzregister.set_credentials_v1, ) - - @cached_property - def request(self) -> AsyncRequestResourceWithStreamingResponse: - return AsyncRequestResourceWithStreamingResponse(self._transparenzregister.request) diff --git a/src/openregister/resources/transparenzregister/__init__.py b/src/openregister/resources/transparenzregister/__init__.py deleted file mode 100644 index 7bd1047..0000000 --- a/src/openregister/resources/transparenzregister/__init__.py +++ /dev/null @@ -1,33 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .request import ( - RequestResource, - AsyncRequestResource, - RequestResourceWithRawResponse, - AsyncRequestResourceWithRawResponse, - RequestResourceWithStreamingResponse, - AsyncRequestResourceWithStreamingResponse, -) -from .transparenzregister import ( - TransparenzregisterResource, - AsyncTransparenzregisterResource, - TransparenzregisterResourceWithRawResponse, - AsyncTransparenzregisterResourceWithRawResponse, - TransparenzregisterResourceWithStreamingResponse, - AsyncTransparenzregisterResourceWithStreamingResponse, -) - -__all__ = [ - "RequestResource", - "AsyncRequestResource", - "RequestResourceWithRawResponse", - "AsyncRequestResourceWithRawResponse", - "RequestResourceWithStreamingResponse", - "AsyncRequestResourceWithStreamingResponse", - "TransparenzregisterResource", - "AsyncTransparenzregisterResource", - "TransparenzregisterResourceWithRawResponse", - "AsyncTransparenzregisterResourceWithRawResponse", - "TransparenzregisterResourceWithStreamingResponse", - "AsyncTransparenzregisterResourceWithStreamingResponse", -] diff --git a/src/openregister/resources/transparenzregister/request.py b/src/openregister/resources/transparenzregister/request.py deleted file mode 100644 index 91df747..0000000 --- a/src/openregister/resources/transparenzregister/request.py +++ /dev/null @@ -1,274 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -import httpx - -from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given -from ..._utils import path_template, maybe_transform, strip_not_given, async_maybe_transform -from ..._compat import cached_property -from ..._resource import SyncAPIResource, AsyncAPIResource -from ..._response import ( - to_raw_response_wrapper, - to_streamed_response_wrapper, - async_to_raw_response_wrapper, - async_to_streamed_response_wrapper, -) -from ..._base_client import make_request_options -from ...types.transparenzregister import request_create_v1_params -from ...types.transparenzregister.request_get_v1_response import RequestGetV1Response -from ...types.transparenzregister.request_create_v1_response import RequestCreateV1Response - -__all__ = ["RequestResource", "AsyncRequestResource"] - - -class RequestResource(SyncAPIResource): - @cached_property - def with_raw_response(self) -> RequestResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/oregister/openregister-python#accessing-raw-response-data-eg-headers - """ - return RequestResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> RequestResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/oregister/openregister-python#with_streaming_response - """ - return RequestResourceWithStreamingResponse(self) - - def create_v1( - self, - *, - company_id: str | Omit = omit, - x_credential_label: str | Omit = omit, - # 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, - ) -> RequestCreateV1Response: - """Submit a Transparenzregister request for a company using its company ID. - - This - endpoint will initiate the Transparenzregister request process and return a - request ID for tracking. - - Args: - company_id: Unique company identifier. Required unless using X-Credential-Label=test. - Example: DE-HRB-F1103-267645 - - 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 - """ - extra_headers = {**strip_not_given({"X-Credential-Label": x_credential_label}), **(extra_headers or {})} - return self._post( - "/v1/transparenzregister/request", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=maybe_transform({"company_id": company_id}, request_create_v1_params.RequestCreateV1Params), - ), - cast_to=RequestCreateV1Response, - ) - - def get_v1( - self, - request_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, - ) -> RequestGetV1Response: - """Get the results of a Transparenzregister request. - - This endpoint handles all - internal complexity including polling request status, selecting all available - documents, creating Transparenzregister baskets, and returning download URLs - when ready. If the request is still processing, it will return a pending status. - - 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 request_id: - raise ValueError(f"Expected a non-empty value for `request_id` but received {request_id!r}") - return self._get( - path_template("/v1/transparenzregister/request/{request_id}", request_id=request_id), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=RequestGetV1Response, - ) - - -class AsyncRequestResource(AsyncAPIResource): - @cached_property - def with_raw_response(self) -> AsyncRequestResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/oregister/openregister-python#accessing-raw-response-data-eg-headers - """ - return AsyncRequestResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> AsyncRequestResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/oregister/openregister-python#with_streaming_response - """ - return AsyncRequestResourceWithStreamingResponse(self) - - async def create_v1( - self, - *, - company_id: str | Omit = omit, - x_credential_label: str | Omit = omit, - # 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, - ) -> RequestCreateV1Response: - """Submit a Transparenzregister request for a company using its company ID. - - This - endpoint will initiate the Transparenzregister request process and return a - request ID for tracking. - - Args: - company_id: Unique company identifier. Required unless using X-Credential-Label=test. - Example: DE-HRB-F1103-267645 - - 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 - """ - extra_headers = {**strip_not_given({"X-Credential-Label": x_credential_label}), **(extra_headers or {})} - return await self._post( - "/v1/transparenzregister/request", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=await async_maybe_transform( - {"company_id": company_id}, request_create_v1_params.RequestCreateV1Params - ), - ), - cast_to=RequestCreateV1Response, - ) - - async def get_v1( - self, - request_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, - ) -> RequestGetV1Response: - """Get the results of a Transparenzregister request. - - This endpoint handles all - internal complexity including polling request status, selecting all available - documents, creating Transparenzregister baskets, and returning download URLs - when ready. If the request is still processing, it will return a pending status. - - 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 request_id: - raise ValueError(f"Expected a non-empty value for `request_id` but received {request_id!r}") - return await self._get( - path_template("/v1/transparenzregister/request/{request_id}", request_id=request_id), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=RequestGetV1Response, - ) - - -class RequestResourceWithRawResponse: - def __init__(self, request: RequestResource) -> None: - self._request = request - - self.create_v1 = to_raw_response_wrapper( - request.create_v1, - ) - self.get_v1 = to_raw_response_wrapper( - request.get_v1, - ) - - -class AsyncRequestResourceWithRawResponse: - def __init__(self, request: AsyncRequestResource) -> None: - self._request = request - - self.create_v1 = async_to_raw_response_wrapper( - request.create_v1, - ) - self.get_v1 = async_to_raw_response_wrapper( - request.get_v1, - ) - - -class RequestResourceWithStreamingResponse: - def __init__(self, request: RequestResource) -> None: - self._request = request - - self.create_v1 = to_streamed_response_wrapper( - request.create_v1, - ) - self.get_v1 = to_streamed_response_wrapper( - request.get_v1, - ) - - -class AsyncRequestResourceWithStreamingResponse: - def __init__(self, request: AsyncRequestResource) -> None: - self._request = request - - self.create_v1 = async_to_streamed_response_wrapper( - request.create_v1, - ) - self.get_v1 = async_to_streamed_response_wrapper( - request.get_v1, - ) diff --git a/src/openregister/types/transparenzregister/__init__.py b/src/openregister/types/transparenzregister/__init__.py index 72be816..f8ee8b1 100644 --- a/src/openregister/types/transparenzregister/__init__.py +++ b/src/openregister/types/transparenzregister/__init__.py @@ -1,7 +1,3 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. from __future__ import annotations - -from .request_get_v1_response import RequestGetV1Response as RequestGetV1Response -from .request_create_v1_params import RequestCreateV1Params as RequestCreateV1Params -from .request_create_v1_response import RequestCreateV1Response as RequestCreateV1Response diff --git a/src/openregister/types/transparenzregister/request_create_v1_params.py b/src/openregister/types/transparenzregister/request_create_v1_params.py deleted file mode 100644 index f046d0f..0000000 --- a/src/openregister/types/transparenzregister/request_create_v1_params.py +++ /dev/null @@ -1,19 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing_extensions import Annotated, TypedDict - -from ..._utils import PropertyInfo - -__all__ = ["RequestCreateV1Params"] - - -class RequestCreateV1Params(TypedDict, total=False): - company_id: str - """Unique company identifier. - - Required unless using X-Credential-Label=test. Example: DE-HRB-F1103-267645 - """ - - x_credential_label: Annotated[str, PropertyInfo(alias="X-Credential-Label")] diff --git a/src/openregister/types/transparenzregister/request_create_v1_response.py b/src/openregister/types/transparenzregister/request_create_v1_response.py deleted file mode 100644 index 9cb2f32..0000000 --- a/src/openregister/types/transparenzregister/request_create_v1_response.py +++ /dev/null @@ -1,12 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from ..._models import BaseModel - -__all__ = ["RequestCreateV1Response"] - - -class RequestCreateV1Response(BaseModel): - """Response from submitting a document request.""" - - request_id: str - """Request ID for tracking the document request. Example: "req_12345678" """ diff --git a/src/openregister/types/transparenzregister/request_get_v1_response.py b/src/openregister/types/transparenzregister/request_get_v1_response.py deleted file mode 100644 index b4db87a..0000000 --- a/src/openregister/types/transparenzregister/request_get_v1_response.py +++ /dev/null @@ -1,45 +0,0 @@ -# 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__ = ["RequestGetV1Response", "DownloadURL"] - - -class DownloadURL(BaseModel): - """Download URL for a document with format information.""" - - document_id: str - """Stable UUID for this document.""" - - filename: str - """ - Suggested filename for the download. Example: "registerauszug_company_12345.pdf" - """ - - format: str - """Format of the downloadable document. Example: "xml", "pdf", "json" """ - - url: str - """ - Download URL for the document. Example: - "https://api.example.com/download/abc123" - """ - - -class RequestGetV1Response(BaseModel): - """ - Response containing document request results and download URLs. - All internal complexity (document IDs, baskets, polling) is handled automatically. - """ - - request_id: str - """Request ID that was used to submit the request. Example: "req_12345678" """ - - status: Literal["completed", "processing", "failed"] - """Status of the Transparenzregister request.""" - - download_urls: Optional[List[DownloadURL]] = None - """URLs for downloading all available documents.""" diff --git a/src/openregister/types/transparenzregister_set_credentials_v1_params.py b/src/openregister/types/transparenzregister_set_credentials_v1_params.py index d90b764..21b0ee6 100644 --- a/src/openregister/types/transparenzregister_set_credentials_v1_params.py +++ b/src/openregister/types/transparenzregister_set_credentials_v1_params.py @@ -12,15 +12,13 @@ class TransparenzregisterSetCredentialsV1Params(TypedDict, total=False): """Password for Transparenzregister API access.""" username: Required[str] - """ - Username for Transparenzregister API access. Example: - "testnutzer-eis@transparenzregister.de" - """ + """Username for Transparenzregister API access. Example: "compliance@example.com" """ - credential_label: str - """Label to identify this set of credentials. + name: str + """Name to identify this set of credentials. Allows storing multiple Transparenzregister credentials per user (e.g., for - different accounts or clients). Defaults to 'default' if not provided. Example: + different accounts or clients). Defaults to 'default' if not provided. Cannot be + `sandbox` because that name is reserved for test-mode extracts. Example: "client_a" """ diff --git a/tests/api_resources/test_transparenzregister.py b/tests/api_resources/test_transparenzregister.py index de8b7f4..e47d757 100644 --- a/tests/api_resources/test_transparenzregister.py +++ b/tests/api_resources/test_transparenzregister.py @@ -30,7 +30,7 @@ def test_method_set_credentials_v1_with_all_params(self, client: Openregister) - transparenzregister = client.transparenzregister.set_credentials_v1( password="password", username="username", - credential_label="credential_label", + name="name", ) assert transparenzregister is None @@ -83,7 +83,7 @@ async def test_method_set_credentials_v1_with_all_params(self, async_client: Asy transparenzregister = await async_client.transparenzregister.set_credentials_v1( password="password", username="username", - credential_label="credential_label", + name="name", ) assert transparenzregister is None diff --git a/tests/api_resources/transparenzregister/__init__.py b/tests/api_resources/transparenzregister/__init__.py deleted file mode 100644 index fd8019a..0000000 --- a/tests/api_resources/transparenzregister/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/transparenzregister/test_request.py b/tests/api_resources/transparenzregister/test_request.py deleted file mode 100644 index 0aa9f6c..0000000 --- a/tests/api_resources/transparenzregister/test_request.py +++ /dev/null @@ -1,185 +0,0 @@ -# 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 tests.utils import assert_matches_type -from openregister import Openregister, AsyncOpenregister -from openregister.types.transparenzregister import ( - RequestGetV1Response, - RequestCreateV1Response, -) - -base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") - - -class TestRequest: - parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - def test_method_create_v1(self, client: Openregister) -> None: - request = client.transparenzregister.request.create_v1() - assert_matches_type(RequestCreateV1Response, request, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - def test_method_create_v1_with_all_params(self, client: Openregister) -> None: - request = client.transparenzregister.request.create_v1( - company_id="company_id", - x_credential_label="X-Credential-Label", - ) - assert_matches_type(RequestCreateV1Response, request, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - def test_raw_response_create_v1(self, client: Openregister) -> None: - response = client.transparenzregister.request.with_raw_response.create_v1() - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - request = response.parse() - assert_matches_type(RequestCreateV1Response, request, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - def test_streaming_response_create_v1(self, client: Openregister) -> None: - with client.transparenzregister.request.with_streaming_response.create_v1() as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - request = response.parse() - assert_matches_type(RequestCreateV1Response, request, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - def test_method_get_v1(self, client: Openregister) -> None: - request = client.transparenzregister.request.get_v1( - "request_id", - ) - assert_matches_type(RequestGetV1Response, request, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - def test_raw_response_get_v1(self, client: Openregister) -> None: - response = client.transparenzregister.request.with_raw_response.get_v1( - "request_id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - request = response.parse() - assert_matches_type(RequestGetV1Response, request, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - def test_streaming_response_get_v1(self, client: Openregister) -> None: - with client.transparenzregister.request.with_streaming_response.get_v1( - "request_id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - request = response.parse() - assert_matches_type(RequestGetV1Response, request, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - def test_path_params_get_v1(self, client: Openregister) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `request_id` but received ''"): - client.transparenzregister.request.with_raw_response.get_v1( - "", - ) - - -class TestAsyncRequest: - parametrize = pytest.mark.parametrize( - "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] - ) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - async def test_method_create_v1(self, async_client: AsyncOpenregister) -> None: - request = await async_client.transparenzregister.request.create_v1() - assert_matches_type(RequestCreateV1Response, request, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - async def test_method_create_v1_with_all_params(self, async_client: AsyncOpenregister) -> None: - request = await async_client.transparenzregister.request.create_v1( - company_id="company_id", - x_credential_label="X-Credential-Label", - ) - assert_matches_type(RequestCreateV1Response, request, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - async def test_raw_response_create_v1(self, async_client: AsyncOpenregister) -> None: - response = await async_client.transparenzregister.request.with_raw_response.create_v1() - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - request = await response.parse() - assert_matches_type(RequestCreateV1Response, request, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - async def test_streaming_response_create_v1(self, async_client: AsyncOpenregister) -> None: - async with async_client.transparenzregister.request.with_streaming_response.create_v1() as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - request = await response.parse() - assert_matches_type(RequestCreateV1Response, request, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - async def test_method_get_v1(self, async_client: AsyncOpenregister) -> None: - request = await async_client.transparenzregister.request.get_v1( - "request_id", - ) - assert_matches_type(RequestGetV1Response, request, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - async def test_raw_response_get_v1(self, async_client: AsyncOpenregister) -> None: - response = await async_client.transparenzregister.request.with_raw_response.get_v1( - "request_id", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - request = await response.parse() - assert_matches_type(RequestGetV1Response, request, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - async def test_streaming_response_get_v1(self, async_client: AsyncOpenregister) -> None: - async with async_client.transparenzregister.request.with_streaming_response.get_v1( - "request_id", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - request = await response.parse() - assert_matches_type(RequestGetV1Response, request, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - async def test_path_params_get_v1(self, async_client: AsyncOpenregister) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `request_id` but received ''"): - await async_client.transparenzregister.request.with_raw_response.get_v1( - "", - ) From 1564bbc59fcb88662f14dbf6fa92d06fdd8a6616 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Apr 2026 15:58:30 +0000 Subject: [PATCH 4/8] feat(api): transparenzregister --- .stats.yml | 4 +- api.md | 15 +- src/openregister/_client.py | 5 +- .../resources/transparenzregister/__init__.py | 33 ++ .../resources/transparenzregister/extract.py | 302 ++++++++++++++++++ .../transparenzregister.py | 46 ++- .../types/transparenzregister/__init__.py | 4 + .../extract_create_v1_params.py | 20 ++ .../extract_create_v1_response.py | 174 ++++++++++ .../extract_get_v1_response.py | 174 ++++++++++ .../transparenzregister/__init__.py | 1 + .../transparenzregister/test_extract.py | 185 +++++++++++ 12 files changed, 952 insertions(+), 11 deletions(-) create mode 100644 src/openregister/resources/transparenzregister/__init__.py create mode 100644 src/openregister/resources/transparenzregister/extract.py rename src/openregister/resources/{ => transparenzregister}/transparenzregister.py (84%) create mode 100644 src/openregister/types/transparenzregister/extract_create_v1_params.py create mode 100644 src/openregister/types/transparenzregister/extract_create_v1_response.py create mode 100644 src/openregister/types/transparenzregister/extract_get_v1_response.py create mode 100644 tests/api_resources/transparenzregister/__init__.py create mode 100644 tests/api_resources/transparenzregister/test_extract.py diff --git a/.stats.yml b/.stats.yml index 14e96d0..bbce26e 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 19 +configured_endpoints: 21 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openregister%2Fopenregister-2f01f03707acbaab4e506fdd89610379d13f8c086dce1dd8933feefd537c8b5c.yml openapi_spec_hash: 9e3e745d3c5e9440f7500db48d5f3f67 -config_hash: 5bfcfda26d3c6818d4f965aa201ed985 +config_hash: fa2fd8bbc637fff67a88ad2f1d6c603d diff --git a/api.md b/api.md index e316eef..ce2ab76 100644 --- a/api.md +++ b/api.md @@ -110,4 +110,17 @@ Methods: Methods: -- client.transparenzregister.set_credentials_v1(\*\*params) -> None +- client.transparenzregister.set_credentials_v1(\*\*params) -> None + +## Extract + +Types: + +```python +from openregister.types.transparenzregister import ExtractCreateV1Response, ExtractGetV1Response +``` + +Methods: + +- client.transparenzregister.extract.create_v1(\*\*params) -> ExtractCreateV1Response +- client.transparenzregister.extract.get_v1(extract_id) -> ExtractGetV1Response diff --git a/src/openregister/_client.py b/src/openregister/_client.py index 64cc58a..8369643 100644 --- a/src/openregister/_client.py +++ b/src/openregister/_client.py @@ -37,7 +37,10 @@ from .resources.company import CompanyResource, AsyncCompanyResource from .resources.monitor import MonitorResource, AsyncMonitorResource from .resources.document import DocumentResource, AsyncDocumentResource - from .resources.transparenzregister import TransparenzregisterResource, AsyncTransparenzregisterResource + from .resources.transparenzregister.transparenzregister import ( + TransparenzregisterResource, + AsyncTransparenzregisterResource, + ) __all__ = [ "Timeout", diff --git a/src/openregister/resources/transparenzregister/__init__.py b/src/openregister/resources/transparenzregister/__init__.py new file mode 100644 index 0000000..e55276c --- /dev/null +++ b/src/openregister/resources/transparenzregister/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .extract import ( + ExtractResource, + AsyncExtractResource, + ExtractResourceWithRawResponse, + AsyncExtractResourceWithRawResponse, + ExtractResourceWithStreamingResponse, + AsyncExtractResourceWithStreamingResponse, +) +from .transparenzregister import ( + TransparenzregisterResource, + AsyncTransparenzregisterResource, + TransparenzregisterResourceWithRawResponse, + AsyncTransparenzregisterResourceWithRawResponse, + TransparenzregisterResourceWithStreamingResponse, + AsyncTransparenzregisterResourceWithStreamingResponse, +) + +__all__ = [ + "ExtractResource", + "AsyncExtractResource", + "ExtractResourceWithRawResponse", + "AsyncExtractResourceWithRawResponse", + "ExtractResourceWithStreamingResponse", + "AsyncExtractResourceWithStreamingResponse", + "TransparenzregisterResource", + "AsyncTransparenzregisterResource", + "TransparenzregisterResourceWithRawResponse", + "AsyncTransparenzregisterResourceWithRawResponse", + "TransparenzregisterResourceWithStreamingResponse", + "AsyncTransparenzregisterResourceWithStreamingResponse", +] diff --git a/src/openregister/resources/transparenzregister/extract.py b/src/openregister/resources/transparenzregister/extract.py new file mode 100644 index 0000000..8b7d341 --- /dev/null +++ b/src/openregister/resources/transparenzregister/extract.py @@ -0,0 +1,302 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given +from ..._utils import path_template, maybe_transform, strip_not_given, async_maybe_transform +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..._base_client import make_request_options +from ...types.transparenzregister import extract_create_v1_params +from ...types.transparenzregister.extract_get_v1_response import ExtractGetV1Response +from ...types.transparenzregister.extract_create_v1_response import ExtractCreateV1Response + +__all__ = ["ExtractResource", "AsyncExtractResource"] + + +class ExtractResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> ExtractResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/oregister/openregister-python#accessing-raw-response-data-eg-headers + """ + return ExtractResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> ExtractResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/oregister/openregister-python#with_streaming_response + """ + return ExtractResourceWithStreamingResponse(self) + + def create_v1( + self, + *, + company_id: str | Omit = omit, + x_credential_name: str | Omit = omit, + # 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, + ) -> ExtractCreateV1Response: + """ + Submit a Transparenzregister extract request and return an extract resource with + processing status. + + Sandbox integration testing (recommended for all non-production testing): + + - Send `X-Credential-Name: sandbox`. + - Do not send `company_id` (an empty body `{}` is valid). + - OpenRegister uses the Transparenzregister test environment and built-in test + authentication. + - The request is submitted with the fixed test EKRN `DE727032388716`. + - The response has `company_id: null`. + + Production usage: + + - Omit `X-Credential-Name` or use `default` / another stored credential name. + - `company_id` is required and must resolve to exactly one Transparenzregister + legal entity. + + Args: + company_id: Unique company identifier. Required unless `X-Credential-Name` is set to + `sandbox`. In sandbox mode this field should be omitted. Example: + DE-HRB-F1103-267645 + + 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 + """ + extra_headers = {**strip_not_given({"X-Credential-Name": x_credential_name}), **(extra_headers or {})} + return self._post( + "/v1/transparenzregister/extracts", + body=maybe_transform({"company_id": company_id}, extract_create_v1_params.ExtractCreateV1Params), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=ExtractCreateV1Response, + ) + + def get_v1( + self, + extract_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, + ) -> ExtractGetV1Response: + """Get the results of a Transparenzregister extract request. + + This endpoint handles + all internal complexity including polling request status, selecting all + available documents, creating Transparenzregister baskets, and returning + download URLs when ready. If the request is still processing, it will return a + pending status. Polling reuses the credential mode stored on the extract at + create time. Sandbox extracts keep using the Transparenzregister test client + automatically; no credential header is accepted on this endpoint. + + 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 extract_id: + raise ValueError(f"Expected a non-empty value for `extract_id` but received {extract_id!r}") + return self._get( + path_template("/v1/transparenzregister/extracts/{extract_id}", extract_id=extract_id), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=ExtractGetV1Response, + ) + + +class AsyncExtractResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncExtractResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/oregister/openregister-python#accessing-raw-response-data-eg-headers + """ + return AsyncExtractResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncExtractResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/oregister/openregister-python#with_streaming_response + """ + return AsyncExtractResourceWithStreamingResponse(self) + + async def create_v1( + self, + *, + company_id: str | Omit = omit, + x_credential_name: str | Omit = omit, + # 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, + ) -> ExtractCreateV1Response: + """ + Submit a Transparenzregister extract request and return an extract resource with + processing status. + + Sandbox integration testing (recommended for all non-production testing): + + - Send `X-Credential-Name: sandbox`. + - Do not send `company_id` (an empty body `{}` is valid). + - OpenRegister uses the Transparenzregister test environment and built-in test + authentication. + - The request is submitted with the fixed test EKRN `DE727032388716`. + - The response has `company_id: null`. + + Production usage: + + - Omit `X-Credential-Name` or use `default` / another stored credential name. + - `company_id` is required and must resolve to exactly one Transparenzregister + legal entity. + + Args: + company_id: Unique company identifier. Required unless `X-Credential-Name` is set to + `sandbox`. In sandbox mode this field should be omitted. Example: + DE-HRB-F1103-267645 + + 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 + """ + extra_headers = {**strip_not_given({"X-Credential-Name": x_credential_name}), **(extra_headers or {})} + return await self._post( + "/v1/transparenzregister/extracts", + body=await async_maybe_transform( + {"company_id": company_id}, extract_create_v1_params.ExtractCreateV1Params + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=ExtractCreateV1Response, + ) + + async def get_v1( + self, + extract_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, + ) -> ExtractGetV1Response: + """Get the results of a Transparenzregister extract request. + + This endpoint handles + all internal complexity including polling request status, selecting all + available documents, creating Transparenzregister baskets, and returning + download URLs when ready. If the request is still processing, it will return a + pending status. Polling reuses the credential mode stored on the extract at + create time. Sandbox extracts keep using the Transparenzregister test client + automatically; no credential header is accepted on this endpoint. + + 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 extract_id: + raise ValueError(f"Expected a non-empty value for `extract_id` but received {extract_id!r}") + return await self._get( + path_template("/v1/transparenzregister/extracts/{extract_id}", extract_id=extract_id), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=ExtractGetV1Response, + ) + + +class ExtractResourceWithRawResponse: + def __init__(self, extract: ExtractResource) -> None: + self._extract = extract + + self.create_v1 = to_raw_response_wrapper( + extract.create_v1, + ) + self.get_v1 = to_raw_response_wrapper( + extract.get_v1, + ) + + +class AsyncExtractResourceWithRawResponse: + def __init__(self, extract: AsyncExtractResource) -> None: + self._extract = extract + + self.create_v1 = async_to_raw_response_wrapper( + extract.create_v1, + ) + self.get_v1 = async_to_raw_response_wrapper( + extract.get_v1, + ) + + +class ExtractResourceWithStreamingResponse: + def __init__(self, extract: ExtractResource) -> None: + self._extract = extract + + self.create_v1 = to_streamed_response_wrapper( + extract.create_v1, + ) + self.get_v1 = to_streamed_response_wrapper( + extract.get_v1, + ) + + +class AsyncExtractResourceWithStreamingResponse: + def __init__(self, extract: AsyncExtractResource) -> None: + self._extract = extract + + self.create_v1 = async_to_streamed_response_wrapper( + extract.create_v1, + ) + self.get_v1 = async_to_streamed_response_wrapper( + extract.get_v1, + ) diff --git a/src/openregister/resources/transparenzregister.py b/src/openregister/resources/transparenzregister/transparenzregister.py similarity index 84% rename from src/openregister/resources/transparenzregister.py rename to src/openregister/resources/transparenzregister/transparenzregister.py index d0f15df..9e1fe02 100644 --- a/src/openregister/resources/transparenzregister.py +++ b/src/openregister/resources/transparenzregister/transparenzregister.py @@ -4,23 +4,35 @@ import httpx -from ..types import transparenzregister_set_credentials_v1_params -from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given -from .._utils import maybe_transform, async_maybe_transform -from .._compat import cached_property -from .._resource import SyncAPIResource, AsyncAPIResource -from .._response import ( +from ...types import transparenzregister_set_credentials_v1_params +from .extract import ( + ExtractResource, + AsyncExtractResource, + ExtractResourceWithRawResponse, + AsyncExtractResourceWithRawResponse, + ExtractResourceWithStreamingResponse, + AsyncExtractResourceWithStreamingResponse, +) +from ..._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given +from ..._utils import maybe_transform, async_maybe_transform +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from .._base_client import make_request_options +from ..._base_client import make_request_options __all__ = ["TransparenzregisterResource", "AsyncTransparenzregisterResource"] class TransparenzregisterResource(SyncAPIResource): + @cached_property + def extract(self) -> ExtractResource: + return ExtractResource(self._client) + @cached_property def with_raw_response(self) -> TransparenzregisterResourceWithRawResponse: """ @@ -97,6 +109,10 @@ def set_credentials_v1( class AsyncTransparenzregisterResource(AsyncAPIResource): + @cached_property + def extract(self) -> AsyncExtractResource: + return AsyncExtractResource(self._client) + @cached_property def with_raw_response(self) -> AsyncTransparenzregisterResourceWithRawResponse: """ @@ -180,6 +196,10 @@ def __init__(self, transparenzregister: TransparenzregisterResource) -> None: transparenzregister.set_credentials_v1, ) + @cached_property + def extract(self) -> ExtractResourceWithRawResponse: + return ExtractResourceWithRawResponse(self._transparenzregister.extract) + class AsyncTransparenzregisterResourceWithRawResponse: def __init__(self, transparenzregister: AsyncTransparenzregisterResource) -> None: @@ -189,6 +209,10 @@ def __init__(self, transparenzregister: AsyncTransparenzregisterResource) -> Non transparenzregister.set_credentials_v1, ) + @cached_property + def extract(self) -> AsyncExtractResourceWithRawResponse: + return AsyncExtractResourceWithRawResponse(self._transparenzregister.extract) + class TransparenzregisterResourceWithStreamingResponse: def __init__(self, transparenzregister: TransparenzregisterResource) -> None: @@ -198,6 +222,10 @@ def __init__(self, transparenzregister: TransparenzregisterResource) -> None: transparenzregister.set_credentials_v1, ) + @cached_property + def extract(self) -> ExtractResourceWithStreamingResponse: + return ExtractResourceWithStreamingResponse(self._transparenzregister.extract) + class AsyncTransparenzregisterResourceWithStreamingResponse: def __init__(self, transparenzregister: AsyncTransparenzregisterResource) -> None: @@ -206,3 +234,7 @@ def __init__(self, transparenzregister: AsyncTransparenzregisterResource) -> Non self.set_credentials_v1 = async_to_streamed_response_wrapper( transparenzregister.set_credentials_v1, ) + + @cached_property + def extract(self) -> AsyncExtractResourceWithStreamingResponse: + return AsyncExtractResourceWithStreamingResponse(self._transparenzregister.extract) diff --git a/src/openregister/types/transparenzregister/__init__.py b/src/openregister/types/transparenzregister/__init__.py index f8ee8b1..202649b 100644 --- a/src/openregister/types/transparenzregister/__init__.py +++ b/src/openregister/types/transparenzregister/__init__.py @@ -1,3 +1,7 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. from __future__ import annotations + +from .extract_get_v1_response import ExtractGetV1Response as ExtractGetV1Response +from .extract_create_v1_params import ExtractCreateV1Params as ExtractCreateV1Params +from .extract_create_v1_response import ExtractCreateV1Response as ExtractCreateV1Response diff --git a/src/openregister/types/transparenzregister/extract_create_v1_params.py b/src/openregister/types/transparenzregister/extract_create_v1_params.py new file mode 100644 index 0000000..33763b4 --- /dev/null +++ b/src/openregister/types/transparenzregister/extract_create_v1_params.py @@ -0,0 +1,20 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["ExtractCreateV1Params"] + + +class ExtractCreateV1Params(TypedDict, total=False): + company_id: str + """ + Unique company identifier. Required unless `X-Credential-Name` is set to + `sandbox`. In sandbox mode this field should be omitted. Example: + DE-HRB-F1103-267645 + """ + + x_credential_name: Annotated[str, PropertyInfo(alias="X-Credential-Name")] diff --git a/src/openregister/types/transparenzregister/extract_create_v1_response.py b/src/openregister/types/transparenzregister/extract_create_v1_response.py new file mode 100644 index 0000000..ed8f575 --- /dev/null +++ b/src/openregister/types/transparenzregister/extract_create_v1_response.py @@ -0,0 +1,174 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import datetime +from typing import List, Optional +from typing_extensions import Literal + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = [ + "ExtractCreateV1Response", + "Document", + "Report", + "ReportGroup", + "ReportStatusFlags", + "ReportUbo", + "ReportUboInterest", + "ReportUboNaturalPerson", + "ReportValidity", + "ReportValidityFrom", + "ReportValidityUntil", +] + + +class Document(BaseModel): + """Download URL for a document with format information.""" + + document_id: str + """Stable UUID for this document.""" + + filename: str + """ + Suggested filename for the download. Example: "registerauszug_company_12345.pdf" + """ + + format: str + """Format of the downloadable document. Example: "xml", "pdf", "json" """ + + url: str + """ + Download URL for the document. Example: + "https://api.example.com/download/abc123" + """ + + +class ReportGroup(BaseModel): + description: Optional[str] = None + + interest_type: Optional[str] = None + + position: Optional[int] = None + + +class ReportStatusFlags(BaseModel): + corrected_by_reference: Optional[str] = None + + corrected_references: Optional[List[str]] = None + + deleted: Optional[bool] = None + + deletion_date: Optional[datetime.date] = None + + discrepancy_note: Optional[str] = None + + +class ReportUboInterest(BaseModel): + percentage: Optional[float] = None + + scope: Optional[str] = None + + type: Optional[str] = None + + +class ReportUboNaturalPerson(BaseModel): + city: Optional[str] = None + + country: Optional[str] = None + + date_of_birth: Optional[datetime.date] = None + + first_name: Optional[str] = None + + full_name: Optional[str] = None + + last_name: Optional[str] = None + + nationalities: Optional[List[str]] = None + """ISO 3166-1 alpha-2 nationality codes where available.""" + + title: Optional[str] = None + + +class ReportUbo(BaseModel): + interest: Optional[ReportUboInterest] = None + + natural_person: Optional[ReportUboNaturalPerson] = None + + position: Optional[int] = None + + +class ReportValidityFrom(BaseModel): + date: Optional[datetime.date] = None + + note: Optional[str] = None + + +class ReportValidityUntil(BaseModel): + date: Optional[datetime.date] = None + + note: Optional[str] = None + + +class ReportValidity(BaseModel): + from_: Optional[ReportValidityFrom] = FieldInfo(alias="from", default=None) + + until: Optional[ReportValidityUntil] = None + + +class Report(BaseModel): + """Parsed Transparenzregister extract report limited to UBO-relevant fields.""" + + created_at: Optional[datetime.date] = None + """Extract creation date.""" + + fictional_ubo_reason: Optional[str] = None + """Reason indicating no natural person UBO could be determined.""" + + groups: Optional[List[ReportGroup]] = None + + notice_type: Optional[str] = None + """Type of Transparenzregister notice.""" + + status_flags: Optional[ReportStatusFlags] = None + + ubos: Optional[List[ReportUbo]] = None + + validity: Optional[ReportValidity] = None + + +class ExtractCreateV1Response(BaseModel): + """ + Transparenzregister extract resource including processing state, parsed report, and downloadable documents. + """ + + id: str + """Stable extract identifier. Example: "tre_12345678" """ + + status: Literal["completed", "processing", "failed"] + """Status of the Transparenzregister extract.""" + + company_id: Optional[str] = None + """ + Company identifier associated with this extract request. May be null when using + sandbox credentials. + """ + + completed_at: Optional[datetime.datetime] = None + """Timestamp when extract processing completed.""" + + documents: Optional[List[Document]] = None + """URLs for downloading available extract documents.""" + + ekrn: Optional[str] = None + """EKRN used to request this extract.""" + + reference_number: Optional[str] = None + """Transparenzregister reference number from the extract.""" + + report: Optional[Report] = None + """Parsed Transparenzregister extract report limited to UBO-relevant fields.""" + + submitted_at: Optional[datetime.datetime] = None + """Timestamp when extract submission started.""" diff --git a/src/openregister/types/transparenzregister/extract_get_v1_response.py b/src/openregister/types/transparenzregister/extract_get_v1_response.py new file mode 100644 index 0000000..2ee9e5b --- /dev/null +++ b/src/openregister/types/transparenzregister/extract_get_v1_response.py @@ -0,0 +1,174 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import datetime +from typing import List, Optional +from typing_extensions import Literal + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = [ + "ExtractGetV1Response", + "Document", + "Report", + "ReportGroup", + "ReportStatusFlags", + "ReportUbo", + "ReportUboInterest", + "ReportUboNaturalPerson", + "ReportValidity", + "ReportValidityFrom", + "ReportValidityUntil", +] + + +class Document(BaseModel): + """Download URL for a document with format information.""" + + document_id: str + """Stable UUID for this document.""" + + filename: str + """ + Suggested filename for the download. Example: "registerauszug_company_12345.pdf" + """ + + format: str + """Format of the downloadable document. Example: "xml", "pdf", "json" """ + + url: str + """ + Download URL for the document. Example: + "https://api.example.com/download/abc123" + """ + + +class ReportGroup(BaseModel): + description: Optional[str] = None + + interest_type: Optional[str] = None + + position: Optional[int] = None + + +class ReportStatusFlags(BaseModel): + corrected_by_reference: Optional[str] = None + + corrected_references: Optional[List[str]] = None + + deleted: Optional[bool] = None + + deletion_date: Optional[datetime.date] = None + + discrepancy_note: Optional[str] = None + + +class ReportUboInterest(BaseModel): + percentage: Optional[float] = None + + scope: Optional[str] = None + + type: Optional[str] = None + + +class ReportUboNaturalPerson(BaseModel): + city: Optional[str] = None + + country: Optional[str] = None + + date_of_birth: Optional[datetime.date] = None + + first_name: Optional[str] = None + + full_name: Optional[str] = None + + last_name: Optional[str] = None + + nationalities: Optional[List[str]] = None + """ISO 3166-1 alpha-2 nationality codes where available.""" + + title: Optional[str] = None + + +class ReportUbo(BaseModel): + interest: Optional[ReportUboInterest] = None + + natural_person: Optional[ReportUboNaturalPerson] = None + + position: Optional[int] = None + + +class ReportValidityFrom(BaseModel): + date: Optional[datetime.date] = None + + note: Optional[str] = None + + +class ReportValidityUntil(BaseModel): + date: Optional[datetime.date] = None + + note: Optional[str] = None + + +class ReportValidity(BaseModel): + from_: Optional[ReportValidityFrom] = FieldInfo(alias="from", default=None) + + until: Optional[ReportValidityUntil] = None + + +class Report(BaseModel): + """Parsed Transparenzregister extract report limited to UBO-relevant fields.""" + + created_at: Optional[datetime.date] = None + """Extract creation date.""" + + fictional_ubo_reason: Optional[str] = None + """Reason indicating no natural person UBO could be determined.""" + + groups: Optional[List[ReportGroup]] = None + + notice_type: Optional[str] = None + """Type of Transparenzregister notice.""" + + status_flags: Optional[ReportStatusFlags] = None + + ubos: Optional[List[ReportUbo]] = None + + validity: Optional[ReportValidity] = None + + +class ExtractGetV1Response(BaseModel): + """ + Transparenzregister extract resource including processing state, parsed report, and downloadable documents. + """ + + id: str + """Stable extract identifier. Example: "tre_12345678" """ + + status: Literal["completed", "processing", "failed"] + """Status of the Transparenzregister extract.""" + + company_id: Optional[str] = None + """ + Company identifier associated with this extract request. May be null when using + sandbox credentials. + """ + + completed_at: Optional[datetime.datetime] = None + """Timestamp when extract processing completed.""" + + documents: Optional[List[Document]] = None + """URLs for downloading available extract documents.""" + + ekrn: Optional[str] = None + """EKRN used to request this extract.""" + + reference_number: Optional[str] = None + """Transparenzregister reference number from the extract.""" + + report: Optional[Report] = None + """Parsed Transparenzregister extract report limited to UBO-relevant fields.""" + + submitted_at: Optional[datetime.datetime] = None + """Timestamp when extract submission started.""" diff --git a/tests/api_resources/transparenzregister/__init__.py b/tests/api_resources/transparenzregister/__init__.py new file mode 100644 index 0000000..fd8019a --- /dev/null +++ b/tests/api_resources/transparenzregister/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/transparenzregister/test_extract.py b/tests/api_resources/transparenzregister/test_extract.py new file mode 100644 index 0000000..498ac32 --- /dev/null +++ b/tests/api_resources/transparenzregister/test_extract.py @@ -0,0 +1,185 @@ +# 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 tests.utils import assert_matches_type +from openregister import Openregister, AsyncOpenregister +from openregister.types.transparenzregister import ( + ExtractGetV1Response, + ExtractCreateV1Response, +) + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestExtract: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_v1(self, client: Openregister) -> None: + extract = client.transparenzregister.extract.create_v1() + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_v1_with_all_params(self, client: Openregister) -> None: + extract = client.transparenzregister.extract.create_v1( + company_id="company_id", + x_credential_name="X-Credential-Name", + ) + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create_v1(self, client: Openregister) -> None: + response = client.transparenzregister.extract.with_raw_response.create_v1() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + extract = response.parse() + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create_v1(self, client: Openregister) -> None: + with client.transparenzregister.extract.with_streaming_response.create_v1() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + extract = response.parse() + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_get_v1(self, client: Openregister) -> None: + extract = client.transparenzregister.extract.get_v1( + "extract_id", + ) + assert_matches_type(ExtractGetV1Response, extract, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_get_v1(self, client: Openregister) -> None: + response = client.transparenzregister.extract.with_raw_response.get_v1( + "extract_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + extract = response.parse() + assert_matches_type(ExtractGetV1Response, extract, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_get_v1(self, client: Openregister) -> None: + with client.transparenzregister.extract.with_streaming_response.get_v1( + "extract_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + extract = response.parse() + assert_matches_type(ExtractGetV1Response, extract, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_path_params_get_v1(self, client: Openregister) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `extract_id` but received ''"): + client.transparenzregister.extract.with_raw_response.get_v1( + "", + ) + + +class TestAsyncExtract: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_v1(self, async_client: AsyncOpenregister) -> None: + extract = await async_client.transparenzregister.extract.create_v1() + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_v1_with_all_params(self, async_client: AsyncOpenregister) -> None: + extract = await async_client.transparenzregister.extract.create_v1( + company_id="company_id", + x_credential_name="X-Credential-Name", + ) + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create_v1(self, async_client: AsyncOpenregister) -> None: + response = await async_client.transparenzregister.extract.with_raw_response.create_v1() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + extract = await response.parse() + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create_v1(self, async_client: AsyncOpenregister) -> None: + async with async_client.transparenzregister.extract.with_streaming_response.create_v1() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + extract = await response.parse() + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_get_v1(self, async_client: AsyncOpenregister) -> None: + extract = await async_client.transparenzregister.extract.get_v1( + "extract_id", + ) + assert_matches_type(ExtractGetV1Response, extract, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_get_v1(self, async_client: AsyncOpenregister) -> None: + response = await async_client.transparenzregister.extract.with_raw_response.get_v1( + "extract_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + extract = await response.parse() + assert_matches_type(ExtractGetV1Response, extract, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_get_v1(self, async_client: AsyncOpenregister) -> None: + async with async_client.transparenzregister.extract.with_streaming_response.get_v1( + "extract_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + extract = await response.parse() + assert_matches_type(ExtractGetV1Response, extract, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_path_params_get_v1(self, async_client: AsyncOpenregister) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `extract_id` but received ''"): + await async_client.transparenzregister.extract.with_raw_response.get_v1( + "", + ) From d3b2682b3a1f0c02dbb0ffc5bf4bedfbe04f09fa Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 17 Apr 2026 16:01:06 +0000 Subject: [PATCH 5/8] feat(api): manual updates --- .stats.yml | 2 +- api.md | 17 +- .../resources/transparenzregister/extract.py | 19 +- .../types/transparenzregister/__init__.py | 14 +- .../extract_create_v1_response.py | 174 ------------------ .../extract_get_v1_response.py | 174 ------------------ .../transparenzregister_document.py | 26 +++ .../transparenzregister_extract.py | 47 +++++ .../transparenzregister_group.py | 15 ++ .../transparenzregister_report.py | 33 ++++ .../transparenzregister_status_flags.py | 20 ++ .../transparenzregister_ubo.py | 17 ++ .../transparenzregister_ubo_interest.py | 15 ++ .../transparenzregister_ubo_natural_person.py | 27 +++ .../transparenzregister_validity.py | 16 ++ .../transparenzregister_validity_point.py | 14 ++ .../transparenzregister/test_extract.py | 33 ++-- 17 files changed, 281 insertions(+), 382 deletions(-) delete mode 100644 src/openregister/types/transparenzregister/extract_create_v1_response.py delete mode 100644 src/openregister/types/transparenzregister/extract_get_v1_response.py create mode 100644 src/openregister/types/transparenzregister/transparenzregister_document.py create mode 100644 src/openregister/types/transparenzregister/transparenzregister_extract.py create mode 100644 src/openregister/types/transparenzregister/transparenzregister_group.py create mode 100644 src/openregister/types/transparenzregister/transparenzregister_report.py create mode 100644 src/openregister/types/transparenzregister/transparenzregister_status_flags.py create mode 100644 src/openregister/types/transparenzregister/transparenzregister_ubo.py create mode 100644 src/openregister/types/transparenzregister/transparenzregister_ubo_interest.py create mode 100644 src/openregister/types/transparenzregister/transparenzregister_ubo_natural_person.py create mode 100644 src/openregister/types/transparenzregister/transparenzregister_validity.py create mode 100644 src/openregister/types/transparenzregister/transparenzregister_validity_point.py diff --git a/.stats.yml b/.stats.yml index bbce26e..6329833 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 21 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openregister%2Fopenregister-2f01f03707acbaab4e506fdd89610379d13f8c086dce1dd8933feefd537c8b5c.yml openapi_spec_hash: 9e3e745d3c5e9440f7500db48d5f3f67 -config_hash: fa2fd8bbc637fff67a88ad2f1d6c603d +config_hash: 4787134e4ba83a07f1f0c16a34fef46c diff --git a/api.md b/api.md index ce2ab76..a7fa0e0 100644 --- a/api.md +++ b/api.md @@ -117,10 +117,21 @@ Methods: Types: ```python -from openregister.types.transparenzregister import ExtractCreateV1Response, ExtractGetV1Response +from openregister.types.transparenzregister import ( + TransparenzregisterDocument, + TransparenzregisterExtract, + TransparenzregisterGroup, + TransparenzregisterReport, + TransparenzregisterStatusFlags, + TransparenzregisterUbo, + TransparenzregisterUboInterest, + TransparenzregisterUboNaturalPerson, + TransparenzregisterValidity, + TransparenzregisterValidityPoint, +) ``` Methods: -- client.transparenzregister.extract.create_v1(\*\*params) -> ExtractCreateV1Response -- client.transparenzregister.extract.get_v1(extract_id) -> ExtractGetV1Response +- client.transparenzregister.extract.create_v1(\*\*params) -> TransparenzregisterExtract +- client.transparenzregister.extract.get_v1(extract_id) -> TransparenzregisterExtract diff --git a/src/openregister/resources/transparenzregister/extract.py b/src/openregister/resources/transparenzregister/extract.py index 8b7d341..6318a0b 100644 --- a/src/openregister/resources/transparenzregister/extract.py +++ b/src/openregister/resources/transparenzregister/extract.py @@ -16,8 +16,7 @@ ) from ..._base_client import make_request_options from ...types.transparenzregister import extract_create_v1_params -from ...types.transparenzregister.extract_get_v1_response import ExtractGetV1Response -from ...types.transparenzregister.extract_create_v1_response import ExtractCreateV1Response +from ...types.transparenzregister.transparenzregister_extract import TransparenzregisterExtract __all__ = ["ExtractResource", "AsyncExtractResource"] @@ -53,7 +52,7 @@ def create_v1( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> ExtractCreateV1Response: + ) -> TransparenzregisterExtract: """ Submit a Transparenzregister extract request and return an extract resource with processing status. @@ -93,7 +92,7 @@ def create_v1( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=ExtractCreateV1Response, + cast_to=TransparenzregisterExtract, ) def get_v1( @@ -106,7 +105,7 @@ def get_v1( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> ExtractGetV1Response: + ) -> TransparenzregisterExtract: """Get the results of a Transparenzregister extract request. This endpoint handles @@ -133,7 +132,7 @@ def get_v1( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=ExtractGetV1Response, + cast_to=TransparenzregisterExtract, ) @@ -168,7 +167,7 @@ async def create_v1( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> ExtractCreateV1Response: + ) -> TransparenzregisterExtract: """ Submit a Transparenzregister extract request and return an extract resource with processing status. @@ -210,7 +209,7 @@ async def create_v1( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=ExtractCreateV1Response, + cast_to=TransparenzregisterExtract, ) async def get_v1( @@ -223,7 +222,7 @@ async def get_v1( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> ExtractGetV1Response: + ) -> TransparenzregisterExtract: """Get the results of a Transparenzregister extract request. This endpoint handles @@ -250,7 +249,7 @@ async def get_v1( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=ExtractGetV1Response, + cast_to=TransparenzregisterExtract, ) diff --git a/src/openregister/types/transparenzregister/__init__.py b/src/openregister/types/transparenzregister/__init__.py index 202649b..fd0d317 100644 --- a/src/openregister/types/transparenzregister/__init__.py +++ b/src/openregister/types/transparenzregister/__init__.py @@ -2,6 +2,16 @@ from __future__ import annotations -from .extract_get_v1_response import ExtractGetV1Response as ExtractGetV1Response +from .transparenzregister_ubo import TransparenzregisterUbo as TransparenzregisterUbo from .extract_create_v1_params import ExtractCreateV1Params as ExtractCreateV1Params -from .extract_create_v1_response import ExtractCreateV1Response as ExtractCreateV1Response +from .transparenzregister_group import TransparenzregisterGroup as TransparenzregisterGroup +from .transparenzregister_report import TransparenzregisterReport as TransparenzregisterReport +from .transparenzregister_extract import TransparenzregisterExtract as TransparenzregisterExtract +from .transparenzregister_document import TransparenzregisterDocument as TransparenzregisterDocument +from .transparenzregister_validity import TransparenzregisterValidity as TransparenzregisterValidity +from .transparenzregister_status_flags import TransparenzregisterStatusFlags as TransparenzregisterStatusFlags +from .transparenzregister_ubo_interest import TransparenzregisterUboInterest as TransparenzregisterUboInterest +from .transparenzregister_validity_point import TransparenzregisterValidityPoint as TransparenzregisterValidityPoint +from .transparenzregister_ubo_natural_person import ( + TransparenzregisterUboNaturalPerson as TransparenzregisterUboNaturalPerson, +) diff --git a/src/openregister/types/transparenzregister/extract_create_v1_response.py b/src/openregister/types/transparenzregister/extract_create_v1_response.py deleted file mode 100644 index ed8f575..0000000 --- a/src/openregister/types/transparenzregister/extract_create_v1_response.py +++ /dev/null @@ -1,174 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -import datetime -from typing import List, Optional -from typing_extensions import Literal - -from pydantic import Field as FieldInfo - -from ..._models import BaseModel - -__all__ = [ - "ExtractCreateV1Response", - "Document", - "Report", - "ReportGroup", - "ReportStatusFlags", - "ReportUbo", - "ReportUboInterest", - "ReportUboNaturalPerson", - "ReportValidity", - "ReportValidityFrom", - "ReportValidityUntil", -] - - -class Document(BaseModel): - """Download URL for a document with format information.""" - - document_id: str - """Stable UUID for this document.""" - - filename: str - """ - Suggested filename for the download. Example: "registerauszug_company_12345.pdf" - """ - - format: str - """Format of the downloadable document. Example: "xml", "pdf", "json" """ - - url: str - """ - Download URL for the document. Example: - "https://api.example.com/download/abc123" - """ - - -class ReportGroup(BaseModel): - description: Optional[str] = None - - interest_type: Optional[str] = None - - position: Optional[int] = None - - -class ReportStatusFlags(BaseModel): - corrected_by_reference: Optional[str] = None - - corrected_references: Optional[List[str]] = None - - deleted: Optional[bool] = None - - deletion_date: Optional[datetime.date] = None - - discrepancy_note: Optional[str] = None - - -class ReportUboInterest(BaseModel): - percentage: Optional[float] = None - - scope: Optional[str] = None - - type: Optional[str] = None - - -class ReportUboNaturalPerson(BaseModel): - city: Optional[str] = None - - country: Optional[str] = None - - date_of_birth: Optional[datetime.date] = None - - first_name: Optional[str] = None - - full_name: Optional[str] = None - - last_name: Optional[str] = None - - nationalities: Optional[List[str]] = None - """ISO 3166-1 alpha-2 nationality codes where available.""" - - title: Optional[str] = None - - -class ReportUbo(BaseModel): - interest: Optional[ReportUboInterest] = None - - natural_person: Optional[ReportUboNaturalPerson] = None - - position: Optional[int] = None - - -class ReportValidityFrom(BaseModel): - date: Optional[datetime.date] = None - - note: Optional[str] = None - - -class ReportValidityUntil(BaseModel): - date: Optional[datetime.date] = None - - note: Optional[str] = None - - -class ReportValidity(BaseModel): - from_: Optional[ReportValidityFrom] = FieldInfo(alias="from", default=None) - - until: Optional[ReportValidityUntil] = None - - -class Report(BaseModel): - """Parsed Transparenzregister extract report limited to UBO-relevant fields.""" - - created_at: Optional[datetime.date] = None - """Extract creation date.""" - - fictional_ubo_reason: Optional[str] = None - """Reason indicating no natural person UBO could be determined.""" - - groups: Optional[List[ReportGroup]] = None - - notice_type: Optional[str] = None - """Type of Transparenzregister notice.""" - - status_flags: Optional[ReportStatusFlags] = None - - ubos: Optional[List[ReportUbo]] = None - - validity: Optional[ReportValidity] = None - - -class ExtractCreateV1Response(BaseModel): - """ - Transparenzregister extract resource including processing state, parsed report, and downloadable documents. - """ - - id: str - """Stable extract identifier. Example: "tre_12345678" """ - - status: Literal["completed", "processing", "failed"] - """Status of the Transparenzregister extract.""" - - company_id: Optional[str] = None - """ - Company identifier associated with this extract request. May be null when using - sandbox credentials. - """ - - completed_at: Optional[datetime.datetime] = None - """Timestamp when extract processing completed.""" - - documents: Optional[List[Document]] = None - """URLs for downloading available extract documents.""" - - ekrn: Optional[str] = None - """EKRN used to request this extract.""" - - reference_number: Optional[str] = None - """Transparenzregister reference number from the extract.""" - - report: Optional[Report] = None - """Parsed Transparenzregister extract report limited to UBO-relevant fields.""" - - submitted_at: Optional[datetime.datetime] = None - """Timestamp when extract submission started.""" diff --git a/src/openregister/types/transparenzregister/extract_get_v1_response.py b/src/openregister/types/transparenzregister/extract_get_v1_response.py deleted file mode 100644 index 2ee9e5b..0000000 --- a/src/openregister/types/transparenzregister/extract_get_v1_response.py +++ /dev/null @@ -1,174 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -import datetime -from typing import List, Optional -from typing_extensions import Literal - -from pydantic import Field as FieldInfo - -from ..._models import BaseModel - -__all__ = [ - "ExtractGetV1Response", - "Document", - "Report", - "ReportGroup", - "ReportStatusFlags", - "ReportUbo", - "ReportUboInterest", - "ReportUboNaturalPerson", - "ReportValidity", - "ReportValidityFrom", - "ReportValidityUntil", -] - - -class Document(BaseModel): - """Download URL for a document with format information.""" - - document_id: str - """Stable UUID for this document.""" - - filename: str - """ - Suggested filename for the download. Example: "registerauszug_company_12345.pdf" - """ - - format: str - """Format of the downloadable document. Example: "xml", "pdf", "json" """ - - url: str - """ - Download URL for the document. Example: - "https://api.example.com/download/abc123" - """ - - -class ReportGroup(BaseModel): - description: Optional[str] = None - - interest_type: Optional[str] = None - - position: Optional[int] = None - - -class ReportStatusFlags(BaseModel): - corrected_by_reference: Optional[str] = None - - corrected_references: Optional[List[str]] = None - - deleted: Optional[bool] = None - - deletion_date: Optional[datetime.date] = None - - discrepancy_note: Optional[str] = None - - -class ReportUboInterest(BaseModel): - percentage: Optional[float] = None - - scope: Optional[str] = None - - type: Optional[str] = None - - -class ReportUboNaturalPerson(BaseModel): - city: Optional[str] = None - - country: Optional[str] = None - - date_of_birth: Optional[datetime.date] = None - - first_name: Optional[str] = None - - full_name: Optional[str] = None - - last_name: Optional[str] = None - - nationalities: Optional[List[str]] = None - """ISO 3166-1 alpha-2 nationality codes where available.""" - - title: Optional[str] = None - - -class ReportUbo(BaseModel): - interest: Optional[ReportUboInterest] = None - - natural_person: Optional[ReportUboNaturalPerson] = None - - position: Optional[int] = None - - -class ReportValidityFrom(BaseModel): - date: Optional[datetime.date] = None - - note: Optional[str] = None - - -class ReportValidityUntil(BaseModel): - date: Optional[datetime.date] = None - - note: Optional[str] = None - - -class ReportValidity(BaseModel): - from_: Optional[ReportValidityFrom] = FieldInfo(alias="from", default=None) - - until: Optional[ReportValidityUntil] = None - - -class Report(BaseModel): - """Parsed Transparenzregister extract report limited to UBO-relevant fields.""" - - created_at: Optional[datetime.date] = None - """Extract creation date.""" - - fictional_ubo_reason: Optional[str] = None - """Reason indicating no natural person UBO could be determined.""" - - groups: Optional[List[ReportGroup]] = None - - notice_type: Optional[str] = None - """Type of Transparenzregister notice.""" - - status_flags: Optional[ReportStatusFlags] = None - - ubos: Optional[List[ReportUbo]] = None - - validity: Optional[ReportValidity] = None - - -class ExtractGetV1Response(BaseModel): - """ - Transparenzregister extract resource including processing state, parsed report, and downloadable documents. - """ - - id: str - """Stable extract identifier. Example: "tre_12345678" """ - - status: Literal["completed", "processing", "failed"] - """Status of the Transparenzregister extract.""" - - company_id: Optional[str] = None - """ - Company identifier associated with this extract request. May be null when using - sandbox credentials. - """ - - completed_at: Optional[datetime.datetime] = None - """Timestamp when extract processing completed.""" - - documents: Optional[List[Document]] = None - """URLs for downloading available extract documents.""" - - ekrn: Optional[str] = None - """EKRN used to request this extract.""" - - reference_number: Optional[str] = None - """Transparenzregister reference number from the extract.""" - - report: Optional[Report] = None - """Parsed Transparenzregister extract report limited to UBO-relevant fields.""" - - submitted_at: Optional[datetime.datetime] = None - """Timestamp when extract submission started.""" diff --git a/src/openregister/types/transparenzregister/transparenzregister_document.py b/src/openregister/types/transparenzregister/transparenzregister_document.py new file mode 100644 index 0000000..d4d63b2 --- /dev/null +++ b/src/openregister/types/transparenzregister/transparenzregister_document.py @@ -0,0 +1,26 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from ..._models import BaseModel + +__all__ = ["TransparenzregisterDocument"] + + +class TransparenzregisterDocument(BaseModel): + """Download URL for a document with format information.""" + + document_id: str + """Stable UUID for this document.""" + + filename: str + """ + Suggested filename for the download. Example: "registerauszug_company_12345.pdf" + """ + + format: str + """Format of the downloadable document. Example: "xml", "pdf", "json" """ + + url: str + """ + Download URL for the document. Example: + "https://api.example.com/download/abc123" + """ diff --git a/src/openregister/types/transparenzregister/transparenzregister_extract.py b/src/openregister/types/transparenzregister/transparenzregister_extract.py new file mode 100644 index 0000000..69be760 --- /dev/null +++ b/src/openregister/types/transparenzregister/transparenzregister_extract.py @@ -0,0 +1,47 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import datetime +from typing_extensions import Literal + +from ..._models import BaseModel +from .transparenzregister_report import TransparenzregisterReport +from .transparenzregister_document import TransparenzregisterDocument + +__all__ = ["TransparenzregisterExtract"] + + +class TransparenzregisterExtract(BaseModel): + """ + Transparenzregister extract resource including processing state, parsed report, and downloadable documents. + """ + + id: str + """Stable extract identifier. Example: "tre_12345678" """ + + status: Literal["completed", "processing", "failed"] + """Status of the Transparenzregister extract.""" + + company_id: Optional[str] = None + """ + Company identifier associated with this extract request. May be null when using + sandbox credentials. + """ + + completed_at: Optional[datetime] = None + """Timestamp when extract processing completed.""" + + documents: Optional[List[TransparenzregisterDocument]] = None + """URLs for downloading available extract documents.""" + + ekrn: Optional[str] = None + """EKRN used to request this extract.""" + + reference_number: Optional[str] = None + """Transparenzregister reference number from the extract.""" + + report: Optional[TransparenzregisterReport] = None + """Parsed Transparenzregister extract report limited to UBO-relevant fields.""" + + submitted_at: Optional[datetime] = None + """Timestamp when extract submission started.""" diff --git a/src/openregister/types/transparenzregister/transparenzregister_group.py b/src/openregister/types/transparenzregister/transparenzregister_group.py new file mode 100644 index 0000000..8a307c3 --- /dev/null +++ b/src/openregister/types/transparenzregister/transparenzregister_group.py @@ -0,0 +1,15 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional + +from ..._models import BaseModel + +__all__ = ["TransparenzregisterGroup"] + + +class TransparenzregisterGroup(BaseModel): + description: Optional[str] = None + + interest_type: Optional[str] = None + + position: Optional[int] = None diff --git a/src/openregister/types/transparenzregister/transparenzregister_report.py b/src/openregister/types/transparenzregister/transparenzregister_report.py new file mode 100644 index 0000000..19d5ec1 --- /dev/null +++ b/src/openregister/types/transparenzregister/transparenzregister_report.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import date + +from ..._models import BaseModel +from .transparenzregister_ubo import TransparenzregisterUbo +from .transparenzregister_group import TransparenzregisterGroup +from .transparenzregister_validity import TransparenzregisterValidity +from .transparenzregister_status_flags import TransparenzregisterStatusFlags + +__all__ = ["TransparenzregisterReport"] + + +class TransparenzregisterReport(BaseModel): + """Parsed Transparenzregister extract report limited to UBO-relevant fields.""" + + created_at: Optional[date] = None + """Extract creation date.""" + + fictional_ubo_reason: Optional[str] = None + """Reason indicating no natural person UBO could be determined.""" + + groups: Optional[List[TransparenzregisterGroup]] = None + + notice_type: Optional[str] = None + """Type of Transparenzregister notice.""" + + status_flags: Optional[TransparenzregisterStatusFlags] = None + + ubos: Optional[List[TransparenzregisterUbo]] = None + + validity: Optional[TransparenzregisterValidity] = None diff --git a/src/openregister/types/transparenzregister/transparenzregister_status_flags.py b/src/openregister/types/transparenzregister/transparenzregister_status_flags.py new file mode 100644 index 0000000..44d08c4 --- /dev/null +++ b/src/openregister/types/transparenzregister/transparenzregister_status_flags.py @@ -0,0 +1,20 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import date + +from ..._models import BaseModel + +__all__ = ["TransparenzregisterStatusFlags"] + + +class TransparenzregisterStatusFlags(BaseModel): + corrected_by_reference: Optional[str] = None + + corrected_references: Optional[List[str]] = None + + deleted: Optional[bool] = None + + deletion_date: Optional[date] = None + + discrepancy_note: Optional[str] = None diff --git a/src/openregister/types/transparenzregister/transparenzregister_ubo.py b/src/openregister/types/transparenzregister/transparenzregister_ubo.py new file mode 100644 index 0000000..c48c561 --- /dev/null +++ b/src/openregister/types/transparenzregister/transparenzregister_ubo.py @@ -0,0 +1,17 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional + +from ..._models import BaseModel +from .transparenzregister_ubo_interest import TransparenzregisterUboInterest +from .transparenzregister_ubo_natural_person import TransparenzregisterUboNaturalPerson + +__all__ = ["TransparenzregisterUbo"] + + +class TransparenzregisterUbo(BaseModel): + interest: Optional[TransparenzregisterUboInterest] = None + + natural_person: Optional[TransparenzregisterUboNaturalPerson] = None + + position: Optional[int] = None diff --git a/src/openregister/types/transparenzregister/transparenzregister_ubo_interest.py b/src/openregister/types/transparenzregister/transparenzregister_ubo_interest.py new file mode 100644 index 0000000..a71e400 --- /dev/null +++ b/src/openregister/types/transparenzregister/transparenzregister_ubo_interest.py @@ -0,0 +1,15 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional + +from ..._models import BaseModel + +__all__ = ["TransparenzregisterUboInterest"] + + +class TransparenzregisterUboInterest(BaseModel): + percentage: Optional[float] = None + + scope: Optional[str] = None + + type: Optional[str] = None diff --git a/src/openregister/types/transparenzregister/transparenzregister_ubo_natural_person.py b/src/openregister/types/transparenzregister/transparenzregister_ubo_natural_person.py new file mode 100644 index 0000000..bb2da46 --- /dev/null +++ b/src/openregister/types/transparenzregister/transparenzregister_ubo_natural_person.py @@ -0,0 +1,27 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional +from datetime import date + +from ..._models import BaseModel + +__all__ = ["TransparenzregisterUboNaturalPerson"] + + +class TransparenzregisterUboNaturalPerson(BaseModel): + city: Optional[str] = None + + country: Optional[str] = None + + date_of_birth: Optional[date] = None + + first_name: Optional[str] = None + + full_name: Optional[str] = None + + last_name: Optional[str] = None + + nationalities: Optional[List[str]] = None + """ISO 3166-1 alpha-2 nationality codes where available.""" + + title: Optional[str] = None diff --git a/src/openregister/types/transparenzregister/transparenzregister_validity.py b/src/openregister/types/transparenzregister/transparenzregister_validity.py new file mode 100644 index 0000000..529350e --- /dev/null +++ b/src/openregister/types/transparenzregister/transparenzregister_validity.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel +from .transparenzregister_validity_point import TransparenzregisterValidityPoint + +__all__ = ["TransparenzregisterValidity"] + + +class TransparenzregisterValidity(BaseModel): + from_: Optional[TransparenzregisterValidityPoint] = FieldInfo(alias="from", default=None) + + until: Optional[TransparenzregisterValidityPoint] = None diff --git a/src/openregister/types/transparenzregister/transparenzregister_validity_point.py b/src/openregister/types/transparenzregister/transparenzregister_validity_point.py new file mode 100644 index 0000000..b99ada6 --- /dev/null +++ b/src/openregister/types/transparenzregister/transparenzregister_validity_point.py @@ -0,0 +1,14 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import datetime +from typing import Optional + +from ..._models import BaseModel + +__all__ = ["TransparenzregisterValidityPoint"] + + +class TransparenzregisterValidityPoint(BaseModel): + date: Optional[datetime.date] = None + + note: Optional[str] = None diff --git a/tests/api_resources/transparenzregister/test_extract.py b/tests/api_resources/transparenzregister/test_extract.py index 498ac32..24543db 100644 --- a/tests/api_resources/transparenzregister/test_extract.py +++ b/tests/api_resources/transparenzregister/test_extract.py @@ -9,10 +9,7 @@ from tests.utils import assert_matches_type from openregister import Openregister, AsyncOpenregister -from openregister.types.transparenzregister import ( - ExtractGetV1Response, - ExtractCreateV1Response, -) +from openregister.types.transparenzregister import TransparenzregisterExtract base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -24,7 +21,7 @@ class TestExtract: @parametrize def test_method_create_v1(self, client: Openregister) -> None: extract = client.transparenzregister.extract.create_v1() - assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -33,7 +30,7 @@ def test_method_create_v1_with_all_params(self, client: Openregister) -> None: company_id="company_id", x_credential_name="X-Credential-Name", ) - assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -43,7 +40,7 @@ def test_raw_response_create_v1(self, client: Openregister) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" extract = response.parse() - assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -53,7 +50,7 @@ def test_streaming_response_create_v1(self, client: Openregister) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" extract = response.parse() - assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) assert cast(Any, response.is_closed) is True @@ -63,7 +60,7 @@ def test_method_get_v1(self, client: Openregister) -> None: extract = client.transparenzregister.extract.get_v1( "extract_id", ) - assert_matches_type(ExtractGetV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -75,7 +72,7 @@ def test_raw_response_get_v1(self, client: Openregister) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" extract = response.parse() - assert_matches_type(ExtractGetV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -87,7 +84,7 @@ def test_streaming_response_get_v1(self, client: Openregister) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" extract = response.parse() - assert_matches_type(ExtractGetV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) assert cast(Any, response.is_closed) is True @@ -109,7 +106,7 @@ class TestAsyncExtract: @parametrize async def test_method_create_v1(self, async_client: AsyncOpenregister) -> None: extract = await async_client.transparenzregister.extract.create_v1() - assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -118,7 +115,7 @@ async def test_method_create_v1_with_all_params(self, async_client: AsyncOpenreg company_id="company_id", x_credential_name="X-Credential-Name", ) - assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -128,7 +125,7 @@ async def test_raw_response_create_v1(self, async_client: AsyncOpenregister) -> assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" extract = await response.parse() - assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -138,7 +135,7 @@ async def test_streaming_response_create_v1(self, async_client: AsyncOpenregiste assert response.http_request.headers.get("X-Stainless-Lang") == "python" extract = await response.parse() - assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) assert cast(Any, response.is_closed) is True @@ -148,7 +145,7 @@ async def test_method_get_v1(self, async_client: AsyncOpenregister) -> None: extract = await async_client.transparenzregister.extract.get_v1( "extract_id", ) - assert_matches_type(ExtractGetV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -160,7 +157,7 @@ async def test_raw_response_get_v1(self, async_client: AsyncOpenregister) -> Non assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" extract = await response.parse() - assert_matches_type(ExtractGetV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -172,7 +169,7 @@ async def test_streaming_response_get_v1(self, async_client: AsyncOpenregister) assert response.http_request.headers.get("X-Stainless-Lang") == "python" extract = await response.parse() - assert_matches_type(ExtractGetV1Response, extract, path=["response"]) + assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) assert cast(Any, response.is_closed) is True From ea8588683342b7c2d19a0ff18ed0d77b6f5dc55d Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 18 Apr 2026 08:22:43 +0000 Subject: [PATCH 6/8] perf(client): optimize file structure copying in multipart requests --- src/openregister/_files.py | 56 +++++++++++++++- src/openregister/_utils/__init__.py | 1 - src/openregister/_utils/_utils.py | 15 ----- tests/test_deepcopy.py | 58 ----------------- tests/test_files.py | 99 ++++++++++++++++++++++++++++- 5 files changed, 151 insertions(+), 78 deletions(-) delete mode 100644 tests/test_deepcopy.py diff --git a/src/openregister/_files.py b/src/openregister/_files.py index cc14c14..0fdce17 100644 --- a/src/openregister/_files.py +++ b/src/openregister/_files.py @@ -3,8 +3,8 @@ import io import os import pathlib -from typing import overload -from typing_extensions import TypeGuard +from typing import Sequence, cast, overload +from typing_extensions import TypeVar, TypeGuard import anyio @@ -17,7 +17,9 @@ HttpxFileContent, HttpxRequestFiles, ) -from ._utils import is_tuple_t, is_mapping_t, is_sequence_t +from ._utils import is_list, is_mapping, is_tuple_t, is_mapping_t, is_sequence_t + +_T = TypeVar("_T") def is_base64_file_input(obj: object) -> TypeGuard[Base64FileInput]: @@ -121,3 +123,51 @@ async def async_read_file_content(file: FileContent) -> HttpxFileContent: return await anyio.Path(file).read_bytes() return file + + +def deepcopy_with_paths(item: _T, paths: Sequence[Sequence[str]]) -> _T: + """Copy only the containers along the given paths. + + Used to guard against mutation by extract_files without copying the entire structure. + Only dicts and lists that lie on a path are copied; everything else + is returned by reference. + + For example, given paths=[["foo", "files", "file"]] and the structure: + { + "foo": { + "bar": {"baz": {}}, + "files": {"file": } + } + } + The root dict, "foo", and "files" are copied (they lie on the path). + "bar" and "baz" are returned by reference (off the path). + """ + return _deepcopy_with_paths(item, paths, 0) + + +def _deepcopy_with_paths(item: _T, paths: Sequence[Sequence[str]], index: int) -> _T: + if not paths: + return item + if is_mapping(item): + key_to_paths: dict[str, list[Sequence[str]]] = {} + for path in paths: + if index < len(path): + key_to_paths.setdefault(path[index], []).append(path) + + # if no path continues through this mapping, it won't be mutated and copying it is redundant + if not key_to_paths: + return item + + result = dict(item) + for key, subpaths in key_to_paths.items(): + if key in result: + result[key] = _deepcopy_with_paths(result[key], subpaths, index + 1) + return cast(_T, result) + if is_list(item): + array_paths = [path for path in paths if index < len(path) and path[index] == ""] + + # if no path expects a list here, nothing will be mutated inside it - return by reference + if not array_paths: + return cast(_T, item) + return cast(_T, [_deepcopy_with_paths(entry, array_paths, index + 1) for entry in item]) + return item diff --git a/src/openregister/_utils/__init__.py b/src/openregister/_utils/__init__.py index 10cb66d..1c090e5 100644 --- a/src/openregister/_utils/__init__.py +++ b/src/openregister/_utils/__init__.py @@ -24,7 +24,6 @@ coerce_integer as coerce_integer, file_from_path as file_from_path, strip_not_given as strip_not_given, - deepcopy_minimal as deepcopy_minimal, get_async_library as get_async_library, maybe_coerce_float as maybe_coerce_float, get_required_header as get_required_header, diff --git a/src/openregister/_utils/_utils.py b/src/openregister/_utils/_utils.py index 63b8cd6..771859f 100644 --- a/src/openregister/_utils/_utils.py +++ b/src/openregister/_utils/_utils.py @@ -177,21 +177,6 @@ def is_iterable(obj: object) -> TypeGuard[Iterable[object]]: return isinstance(obj, Iterable) -def deepcopy_minimal(item: _T) -> _T: - """Minimal reimplementation of copy.deepcopy() that will only copy certain object types: - - - mappings, e.g. `dict` - - list - - This is done for performance reasons. - """ - if is_mapping(item): - return cast(_T, {k: deepcopy_minimal(v) for k, v in item.items()}) - if is_list(item): - return cast(_T, [deepcopy_minimal(entry) for entry in item]) - return item - - # copied from https://github.com/Rapptz/RoboDanny def human_join(seq: Sequence[str], *, delim: str = ", ", final: str = "or") -> str: size = len(seq) diff --git a/tests/test_deepcopy.py b/tests/test_deepcopy.py deleted file mode 100644 index 13a6e4b..0000000 --- a/tests/test_deepcopy.py +++ /dev/null @@ -1,58 +0,0 @@ -from openregister._utils import deepcopy_minimal - - -def assert_different_identities(obj1: object, obj2: object) -> None: - assert obj1 == obj2 - assert id(obj1) != id(obj2) - - -def test_simple_dict() -> None: - obj1 = {"foo": "bar"} - obj2 = deepcopy_minimal(obj1) - assert_different_identities(obj1, obj2) - - -def test_nested_dict() -> None: - obj1 = {"foo": {"bar": True}} - obj2 = deepcopy_minimal(obj1) - assert_different_identities(obj1, obj2) - assert_different_identities(obj1["foo"], obj2["foo"]) - - -def test_complex_nested_dict() -> None: - obj1 = {"foo": {"bar": [{"hello": "world"}]}} - obj2 = deepcopy_minimal(obj1) - assert_different_identities(obj1, obj2) - assert_different_identities(obj1["foo"], obj2["foo"]) - assert_different_identities(obj1["foo"]["bar"], obj2["foo"]["bar"]) - assert_different_identities(obj1["foo"]["bar"][0], obj2["foo"]["bar"][0]) - - -def test_simple_list() -> None: - obj1 = ["a", "b", "c"] - obj2 = deepcopy_minimal(obj1) - assert_different_identities(obj1, obj2) - - -def test_nested_list() -> None: - obj1 = ["a", [1, 2, 3]] - obj2 = deepcopy_minimal(obj1) - assert_different_identities(obj1, obj2) - assert_different_identities(obj1[1], obj2[1]) - - -class MyObject: ... - - -def test_ignores_other_types() -> None: - # custom classes - my_obj = MyObject() - obj1 = {"foo": my_obj} - obj2 = deepcopy_minimal(obj1) - assert_different_identities(obj1, obj2) - assert obj1["foo"] is my_obj - - # tuples - obj3 = ("a", "b") - obj4 = deepcopy_minimal(obj3) - assert obj3 is obj4 diff --git a/tests/test_files.py b/tests/test_files.py index c7c82ce..3c0f2ab 100644 --- a/tests/test_files.py +++ b/tests/test_files.py @@ -4,7 +4,8 @@ import pytest from dirty_equals import IsDict, IsList, IsBytes, IsTuple -from openregister._files import to_httpx_files, async_to_httpx_files +from openregister._files import to_httpx_files, deepcopy_with_paths, async_to_httpx_files +from openregister._utils import extract_files readme_path = Path(__file__).parent.parent.joinpath("README.md") @@ -49,3 +50,99 @@ def test_string_not_allowed() -> None: "file": "foo", # type: ignore } ) + + +def assert_different_identities(obj1: object, obj2: object) -> None: + assert obj1 == obj2 + assert obj1 is not obj2 + + +class TestDeepcopyWithPaths: + def test_copies_top_level_dict(self) -> None: + original = {"file": b"data", "other": "value"} + result = deepcopy_with_paths(original, [["file"]]) + assert_different_identities(result, original) + + def test_file_value_is_same_reference(self) -> None: + file_bytes = b"contents" + original = {"file": file_bytes} + result = deepcopy_with_paths(original, [["file"]]) + assert_different_identities(result, original) + assert result["file"] is file_bytes + + def test_list_popped_wholesale(self) -> None: + files = [b"f1", b"f2"] + original = {"files": files, "title": "t"} + result = deepcopy_with_paths(original, [["files", ""]]) + assert_different_identities(result, original) + result_files = result["files"] + assert isinstance(result_files, list) + assert_different_identities(result_files, files) + + def test_nested_array_path_copies_list_and_elements(self) -> None: + elem1 = {"file": b"f1", "extra": 1} + elem2 = {"file": b"f2", "extra": 2} + original = {"items": [elem1, elem2]} + result = deepcopy_with_paths(original, [["items", "", "file"]]) + assert_different_identities(result, original) + result_items = result["items"] + assert isinstance(result_items, list) + assert_different_identities(result_items, original["items"]) + assert_different_identities(result_items[0], elem1) + assert_different_identities(result_items[1], elem2) + + def test_empty_paths_returns_same_object(self) -> None: + original = {"foo": "bar"} + result = deepcopy_with_paths(original, []) + assert result is original + + def test_multiple_paths(self) -> None: + f1 = b"file1" + f2 = b"file2" + original = {"a": f1, "b": f2, "c": "unchanged"} + result = deepcopy_with_paths(original, [["a"], ["b"]]) + assert_different_identities(result, original) + assert result["a"] is f1 + assert result["b"] is f2 + assert result["c"] is original["c"] + + def test_extract_files_does_not_mutate_original_top_level(self) -> None: + file_bytes = b"contents" + original = {"file": file_bytes, "other": "value"} + + copied = deepcopy_with_paths(original, [["file"]]) + extracted = extract_files(copied, paths=[["file"]]) + + assert extracted == [("file", file_bytes)] + assert original == {"file": file_bytes, "other": "value"} + assert copied == {"other": "value"} + + def test_extract_files_does_not_mutate_original_nested_array_path(self) -> None: + file1 = b"f1" + file2 = b"f2" + original = { + "items": [ + {"file": file1, "extra": 1}, + {"file": file2, "extra": 2}, + ], + "title": "example", + } + + copied = deepcopy_with_paths(original, [["items", "", "file"]]) + extracted = extract_files(copied, paths=[["items", "", "file"]]) + + assert extracted == [("items[][file]", file1), ("items[][file]", file2)] + assert original == { + "items": [ + {"file": file1, "extra": 1}, + {"file": file2, "extra": 2}, + ], + "title": "example", + } + assert copied == { + "items": [ + {"extra": 1}, + {"extra": 2}, + ], + "title": "example", + } From 016e2d316b55825c9eb8257bb96c0463c0b5bc66 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 21 Apr 2026 16:17:07 +0000 Subject: [PATCH 7/8] feat(api): transparenzregister --- .stats.yml | 4 +- api.md | 3 +- .../resources/transparenzregister/extract.py | 13 +++--- .../types/transparenzregister/__init__.py | 1 + .../extract_create_v1_response.py | 40 +++++++++++++++++++ .../transparenzregister/test_extract.py | 21 +++++----- 6 files changed, 64 insertions(+), 18 deletions(-) create mode 100644 src/openregister/types/transparenzregister/extract_create_v1_response.py diff --git a/.stats.yml b/.stats.yml index 6329833..abd72be 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 21 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openregister%2Fopenregister-2f01f03707acbaab4e506fdd89610379d13f8c086dce1dd8933feefd537c8b5c.yml -openapi_spec_hash: 9e3e745d3c5e9440f7500db48d5f3f67 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openregister%2Fopenregister-e885b1154d9d5095a9a771318241cb380641ac4aaf8e81909cb20f4a201fa24f.yml +openapi_spec_hash: 415c8b6bd8c7c5a3d050c2665403dbf3 config_hash: 4787134e4ba83a07f1f0c16a34fef46c diff --git a/api.md b/api.md index a7fa0e0..b9d3c16 100644 --- a/api.md +++ b/api.md @@ -128,10 +128,11 @@ from openregister.types.transparenzregister import ( TransparenzregisterUboNaturalPerson, TransparenzregisterValidity, TransparenzregisterValidityPoint, + ExtractCreateV1Response, ) ``` Methods: -- client.transparenzregister.extract.create_v1(\*\*params) -> TransparenzregisterExtract +- client.transparenzregister.extract.create_v1(\*\*params) -> ExtractCreateV1Response - client.transparenzregister.extract.get_v1(extract_id) -> TransparenzregisterExtract diff --git a/src/openregister/resources/transparenzregister/extract.py b/src/openregister/resources/transparenzregister/extract.py index 6318a0b..92d6e20 100644 --- a/src/openregister/resources/transparenzregister/extract.py +++ b/src/openregister/resources/transparenzregister/extract.py @@ -16,6 +16,7 @@ ) from ..._base_client import make_request_options from ...types.transparenzregister import extract_create_v1_params +from ...types.transparenzregister.extract_create_v1_response import ExtractCreateV1Response from ...types.transparenzregister.transparenzregister_extract import TransparenzregisterExtract __all__ = ["ExtractResource", "AsyncExtractResource"] @@ -52,7 +53,7 @@ def create_v1( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> TransparenzregisterExtract: + ) -> ExtractCreateV1Response: """ Submit a Transparenzregister extract request and return an extract resource with processing status. @@ -68,7 +69,7 @@ def create_v1( Production usage: - - Omit `X-Credential-Name` or use `default` / another stored credential name. + - Always set `X-Credential-Name` to `default` or another stored credential name. - `company_id` is required and must resolve to exactly one Transparenzregister legal entity. @@ -92,7 +93,7 @@ def create_v1( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=TransparenzregisterExtract, + cast_to=ExtractCreateV1Response, ) def get_v1( @@ -167,7 +168,7 @@ async def create_v1( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> TransparenzregisterExtract: + ) -> ExtractCreateV1Response: """ Submit a Transparenzregister extract request and return an extract resource with processing status. @@ -183,7 +184,7 @@ async def create_v1( Production usage: - - Omit `X-Credential-Name` or use `default` / another stored credential name. + - Always set `X-Credential-Name` to `default` or another stored credential name. - `company_id` is required and must resolve to exactly one Transparenzregister legal entity. @@ -209,7 +210,7 @@ async def create_v1( options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=TransparenzregisterExtract, + cast_to=ExtractCreateV1Response, ) async def get_v1( diff --git a/src/openregister/types/transparenzregister/__init__.py b/src/openregister/types/transparenzregister/__init__.py index fd0d317..f6f5ea5 100644 --- a/src/openregister/types/transparenzregister/__init__.py +++ b/src/openregister/types/transparenzregister/__init__.py @@ -5,6 +5,7 @@ from .transparenzregister_ubo import TransparenzregisterUbo as TransparenzregisterUbo from .extract_create_v1_params import ExtractCreateV1Params as ExtractCreateV1Params from .transparenzregister_group import TransparenzregisterGroup as TransparenzregisterGroup +from .extract_create_v1_response import ExtractCreateV1Response as ExtractCreateV1Response from .transparenzregister_report import TransparenzregisterReport as TransparenzregisterReport from .transparenzregister_extract import TransparenzregisterExtract as TransparenzregisterExtract from .transparenzregister_document import TransparenzregisterDocument as TransparenzregisterDocument diff --git a/src/openregister/types/transparenzregister/extract_create_v1_response.py b/src/openregister/types/transparenzregister/extract_create_v1_response.py new file mode 100644 index 0000000..f858c43 --- /dev/null +++ b/src/openregister/types/transparenzregister/extract_create_v1_response.py @@ -0,0 +1,40 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional +from datetime import datetime +from typing_extensions import Literal + +from ..._models import BaseModel + +__all__ = ["ExtractCreateV1Response"] + + +class ExtractCreateV1Response(BaseModel): + """ + Response from creating a Transparenzregister extract. + Only fields known at creation time are present. + Poll `GET /v1/transparenzregister/extracts/{extract_id}` to retrieve report and documents. + """ + + id: str + """Stable extract identifier. + + Use this to poll the get-extract endpoint. Example: "tre_12345678" + """ + + company_id: Optional[str] = None + """ + Company identifier associated with this extract request. May be null when using + sandbox credentials. + """ + + ekrn: Optional[str] = None + """EKRN used to request this extract.""" + + status: Literal["processing"] + """ + Always `processing` on create. Poll the get-extract endpoint for terminal state. + """ + + submitted_at: datetime + """Timestamp when extract submission started.""" diff --git a/tests/api_resources/transparenzregister/test_extract.py b/tests/api_resources/transparenzregister/test_extract.py index 24543db..85cb8d7 100644 --- a/tests/api_resources/transparenzregister/test_extract.py +++ b/tests/api_resources/transparenzregister/test_extract.py @@ -9,7 +9,10 @@ from tests.utils import assert_matches_type from openregister import Openregister, AsyncOpenregister -from openregister.types.transparenzregister import TransparenzregisterExtract +from openregister.types.transparenzregister import ( + ExtractCreateV1Response, + TransparenzregisterExtract, +) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -21,7 +24,7 @@ class TestExtract: @parametrize def test_method_create_v1(self, client: Openregister) -> None: extract = client.transparenzregister.extract.create_v1() - assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -30,7 +33,7 @@ def test_method_create_v1_with_all_params(self, client: Openregister) -> None: company_id="company_id", x_credential_name="X-Credential-Name", ) - assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -40,7 +43,7 @@ def test_raw_response_create_v1(self, client: Openregister) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" extract = response.parse() - assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -50,7 +53,7 @@ def test_streaming_response_create_v1(self, client: Openregister) -> None: assert response.http_request.headers.get("X-Stainless-Lang") == "python" extract = response.parse() - assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) assert cast(Any, response.is_closed) is True @@ -106,7 +109,7 @@ class TestAsyncExtract: @parametrize async def test_method_create_v1(self, async_client: AsyncOpenregister) -> None: extract = await async_client.transparenzregister.extract.create_v1() - assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -115,7 +118,7 @@ async def test_method_create_v1_with_all_params(self, async_client: AsyncOpenreg company_id="company_id", x_credential_name="X-Credential-Name", ) - assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -125,7 +128,7 @@ async def test_raw_response_create_v1(self, async_client: AsyncOpenregister) -> assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" extract = await response.parse() - assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize @@ -135,7 +138,7 @@ async def test_streaming_response_create_v1(self, async_client: AsyncOpenregiste assert response.http_request.headers.get("X-Stainless-Lang") == "python" extract = await response.parse() - assert_matches_type(TransparenzregisterExtract, extract, path=["response"]) + assert_matches_type(ExtractCreateV1Response, extract, path=["response"]) assert cast(Any, response.is_closed) is True From 7cac0074463f7c1cb9206a62209566c5e3fc91fd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 21 Apr 2026 16:17:28 +0000 Subject: [PATCH 8/8] release: 3.4.0 --- .release-please-manifest.json | 2 +- CHANGELOG.md | 17 +++++++++++++++++ pyproject.toml | 2 +- src/openregister/_version.py | 2 +- 4 files changed, 20 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index ff1c7af..2437b41 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "3.3.0" + ".": "3.4.0" } \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 07932f9..722a66c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,22 @@ # Changelog +## 3.4.0 (2026-04-21) + +Full Changelog: [v3.3.0...v3.4.0](https://github.com/oregister/openregister-python/compare/v3.3.0...v3.4.0) + +### Features + +* **api:** manual updates ([d3b2682](https://github.com/oregister/openregister-python/commit/d3b2682b3a1f0c02dbb0ffc5bf4bedfbe04f09fa)) +* **api:** transparenzregister ([016e2d3](https://github.com/oregister/openregister-python/commit/016e2d316b55825c9eb8257bb96c0463c0b5bc66)) +* **api:** transparenzregister ([1564bbc](https://github.com/oregister/openregister-python/commit/1564bbc59fcb88662f14dbf6fa92d06fdd8a6616)) +* **api:** transparenzregister ([cc3039c](https://github.com/oregister/openregister-python/commit/cc3039cfe06010b597aeb5a227ae3f440f47e44b)) +* **api:** transparenzregister endpoints ([264ef57](https://github.com/oregister/openregister-python/commit/264ef57eab2f1eba138decaeb5dc5547d93e677d)) + + +### Performance Improvements + +* **client:** optimize file structure copying in multipart requests ([ea85886](https://github.com/oregister/openregister-python/commit/ea8588683342b7c2d19a0ff18ed0d77b6f5dc55d)) + ## 3.3.0 (2026-04-14) Full Changelog: [v3.2.0...v3.3.0](https://github.com/oregister/openregister-python/compare/v3.2.0...v3.3.0) diff --git a/pyproject.toml b/pyproject.toml index 0e59d56..5612c8b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "openregister-sdk" -version = "3.3.0" +version = "3.4.0" description = "The official Python library for the openregister API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/openregister/_version.py b/src/openregister/_version.py index f006e87..a6ec132 100644 --- a/src/openregister/_version.py +++ b/src/openregister/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "openregister" -__version__ = "3.3.0" # x-release-please-version +__version__ = "3.4.0" # x-release-please-version