anchorbrowser 0.3.13__tar.gz → 0.4.0__tar.gz

anchorbrowser-0.4.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.4.0"
+}

{anchorbrowser-0.3.13 → anchorbrowser-0.4.0}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.4.0 (2025-12-11)
+
+Full Changelog: [v0.3.13...v0.4.0](https://github.com/anchorbrowser/AnchorBrowser-SDK-Python/compare/v0.3.13...v0.4.0)
+
+### Features
+
+* BRO-1383 Add get identity credentials endpoint to SDK ([0548f2f](https://github.com/anchorbrowser/AnchorBrowser-SDK-Python/commit/0548f2fd39fb76b7e972154637aafe317a6ce17f))
+
 ## 0.3.13 (2025-12-09)
 
 Full Changelog: [v0.3.12...v0.3.13](https://github.com/anchorbrowser/AnchorBrowser-SDK-Python/compare/v0.3.12...v0.3.13)

{anchorbrowser-0.3.13 → anchorbrowser-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: anchorbrowser
-Version: 0.3.13
+Version: 0.4.0
 Summary: The official Python library for the anchorbrowser API
 Project-URL: Homepage, https://github.com/anchorbrowser/AnchorBrowser-SDK-Python
 Project-URL: Repository, https://github.com/anchorbrowser/AnchorBrowser-SDK-Python

{anchorbrowser-0.3.13 → anchorbrowser-0.4.0}/api.md

@@ -202,40 +202,39 @@ Methods:
 - <code title="post /v1/events/{event_name}">client.events.<a href="./src/anchorbrowser/resources/events.py">signal</a>(event_name, \*\*<a href="src/anchorbrowser/types/event_signal_params.py">params</a>) -> <a href="./src/anchorbrowser/types/shared/success_response.py">SuccessResponse</a></code>
 - <code title="post /v1/events/{event_name}/wait">client.events.<a href="./src/anchorbrowser/resources/events.py">wait_for</a>(event_name, \*\*<a href="src/anchorbrowser/types/event_wait_for_params.py">params</a>) -> <a href="./src/anchorbrowser/types/event_wait_for_response.py">EventWaitForResponse</a></code>
 
-# BatchSessions
+# Task
 
 Types:
 
 ```python
-from anchorbrowser.types import BatchSessionCreateResponse, BatchSessionRetrieveResponse
+from anchorbrowser.types import TaskCreateResponse, TaskListResponse
 ```
 
 Methods:
 
-- <code title="post /v1/batch-sessions">client.batch_sessions.<a href="./src/anchorbrowser/resources/batch_sessions.py">create</a>(\*\*<a href="src/anchorbrowser/types/batch_session_create_params.py">params</a>) -> <a href="./src/anchorbrowser/types/batch_session_create_response.py">BatchSessionCreateResponse</a></code>
-- <code title="get /v1/batch-sessions/{batch_id}">client.batch_sessions.<a href="./src/anchorbrowser/resources/batch_sessions.py">retrieve</a>(batch_id) -> <a href="./src/anchorbrowser/types/batch_session_retrieve_response.py">BatchSessionRetrieveResponse</a></code>
+- <code title="post /v1/task">client.task.<a href="./src/anchorbrowser/resources/task/task.py">create</a>(\*\*<a href="src/anchorbrowser/types/task_create_params.py">params</a>) -> <a href="./src/anchorbrowser/types/task_create_response.py">TaskCreateResponse</a></code>
+- <code title="get /v1/task">client.task.<a href="./src/anchorbrowser/resources/task/task.py">list</a>(\*\*<a href="src/anchorbrowser/types/task_list_params.py">params</a>) -> <a href="./src/anchorbrowser/types/task_list_response.py">TaskListResponse</a></code>
 
-# Task
+## Run
 
 Types:
 
 ```python
-from anchorbrowser.types import TaskCreateResponse, TaskListResponse
+from anchorbrowser.types.task import RunExecuteResponse
 ```
 
 Methods:
 
-- <code title="post /v1/task">client.task.<a href="./src/anchorbrowser/resources/task/task.py">create</a>(\*\*<a href="src/anchorbrowser/types/task_create_params.py">params</a>) -> <a href="./src/anchorbrowser/types/task_create_response.py">TaskCreateResponse</a></code>
-- <code title="get /v1/task">client.task.<a href="./src/anchorbrowser/resources/task/task.py">list</a>(\*\*<a href="src/anchorbrowser/types/task_list_params.py">params</a>) -> <a href="./src/anchorbrowser/types/task_list_response.py">TaskListResponse</a></code>
+- <code title="post /v1/task/run">client.task.run.<a href="./src/anchorbrowser/resources/task/run.py">execute</a>(\*\*<a href="src/anchorbrowser/types/task/run_execute_params.py">params</a>) -> <a href="./src/anchorbrowser/types/task/run_execute_response.py">RunExecuteResponse</a></code>
 
-## Run
+# Identities
 
 Types:
 
 ```python
-from anchorbrowser.types.task import RunExecuteResponse
+from anchorbrowser.types import IdentityRetrieveCredentialsResponse
 ```
 
 Methods:
 
-- <code title="post /v1/task/run">client.task.run.<a href="./src/anchorbrowser/resources/task/run.py">execute</a>(\*\*<a href="src/anchorbrowser/types/task/run_execute_params.py">params</a>) -> <a href="./src/anchorbrowser/types/task/run_execute_response.py">RunExecuteResponse</a></code>
+- <code title="get /v1/identities/{identity_id}/credentials">client.identities.<a href="./src/anchorbrowser/resources/identities.py">retrieve_credentials</a>(identity_id) -> <a href="./src/anchorbrowser/types/identity_retrieve_credentials_response.py">IdentityRetrieveCredentialsResponse</a></code>

{anchorbrowser-0.3.13 → anchorbrowser-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anchorbrowser"
-version = "0.3.13"
+version = "0.4.0"
 description = "The official Python library for the anchorbrowser API"
 dynamic = ["readme"]
 license = "Apache-2.0"

{anchorbrowser-0.3.13 → anchorbrowser-0.4.0}/src/anchorbrowser/_client.py

@@ -21,7 +21,7 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import task, agent, tools, events, browser, profiles, extensions, batch_sessions
+from .resources import task, agent, tools, events, browser, profiles, extensions, identities
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, AnchorbrowserError
 from ._base_client import (
@@ -51,8 +51,8 @@ class Anchorbrowser(SyncAPIClient):
     browser: browser.BrowserResource
     agent: agent.AgentResource
     events: events.EventsResource
-    batch_sessions: batch_sessions.BatchSessionsResource
     task: task.TaskResource
+    identities: identities.IdentitiesResource
     with_raw_response: AnchorbrowserWithRawResponse
     with_streaming_response: AnchorbrowserWithStreamedResponse
 
@@ -117,8 +117,8 @@ class Anchorbrowser(SyncAPIClient):
         self.browser = browser.BrowserResource(self)
         self.agent = agent.AgentResource(self)
         self.events = events.EventsResource(self)
-        self.batch_sessions = batch_sessions.BatchSessionsResource(self)
         self.task = task.TaskResource(self)
+        self.identities = identities.IdentitiesResource(self)
         self.with_raw_response = AnchorbrowserWithRawResponse(self)
         self.with_streaming_response = AnchorbrowserWithStreamedResponse(self)
 
@@ -235,8 +235,8 @@ class AsyncAnchorbrowser(AsyncAPIClient):
     browser: browser.AsyncBrowserResource
     agent: agent.AsyncAgentResource
     events: events.AsyncEventsResource
-    batch_sessions: batch_sessions.AsyncBatchSessionsResource
     task: task.AsyncTaskResource
+    identities: identities.AsyncIdentitiesResource
     with_raw_response: AsyncAnchorbrowserWithRawResponse
     with_streaming_response: AsyncAnchorbrowserWithStreamedResponse
 
@@ -301,8 +301,8 @@ class AsyncAnchorbrowser(AsyncAPIClient):
         self.browser = browser.AsyncBrowserResource(self)
         self.agent = agent.AsyncAgentResource(self)
         self.events = events.AsyncEventsResource(self)
-        self.batch_sessions = batch_sessions.AsyncBatchSessionsResource(self)
         self.task = task.AsyncTaskResource(self)
+        self.identities = identities.AsyncIdentitiesResource(self)
         self.with_raw_response = AsyncAnchorbrowserWithRawResponse(self)
         self.with_streaming_response = AsyncAnchorbrowserWithStreamedResponse(self)
 
@@ -420,8 +420,8 @@ class AnchorbrowserWithRawResponse:
         self.browser = browser.BrowserResourceWithRawResponse(client.browser)
         self.agent = agent.AgentResourceWithRawResponse(client.agent)
         self.events = events.EventsResourceWithRawResponse(client.events)
-        self.batch_sessions = batch_sessions.BatchSessionsResourceWithRawResponse(client.batch_sessions)
         self.task = task.TaskResourceWithRawResponse(client.task)
+        self.identities = identities.IdentitiesResourceWithRawResponse(client.identities)
 
 
 class AsyncAnchorbrowserWithRawResponse:
@@ -433,8 +433,8 @@ class AsyncAnchorbrowserWithRawResponse:
         self.browser = browser.AsyncBrowserResourceWithRawResponse(client.browser)
         self.agent = agent.AsyncAgentResourceWithRawResponse(client.agent)
         self.events = events.AsyncEventsResourceWithRawResponse(client.events)
-        self.batch_sessions = batch_sessions.AsyncBatchSessionsResourceWithRawResponse(client.batch_sessions)
         self.task = task.AsyncTaskResourceWithRawResponse(client.task)
+        self.identities = identities.AsyncIdentitiesResourceWithRawResponse(client.identities)
 
 
 class AnchorbrowserWithStreamedResponse:
@@ -446,8 +446,8 @@ class AnchorbrowserWithStreamedResponse:
         self.browser = browser.BrowserResourceWithStreamingResponse(client.browser)
         self.agent = agent.AgentResourceWithStreamingResponse(client.agent)
         self.events = events.EventsResourceWithStreamingResponse(client.events)
-        self.batch_sessions = batch_sessions.BatchSessionsResourceWithStreamingResponse(client.batch_sessions)
         self.task = task.TaskResourceWithStreamingResponse(client.task)
+        self.identities = identities.IdentitiesResourceWithStreamingResponse(client.identities)
 
 
 class AsyncAnchorbrowserWithStreamedResponse:
@@ -459,8 +459,8 @@ class AsyncAnchorbrowserWithStreamedResponse:
         self.browser = browser.AsyncBrowserResourceWithStreamingResponse(client.browser)
         self.agent = agent.AsyncAgentResourceWithStreamingResponse(client.agent)
         self.events = events.AsyncEventsResourceWithStreamingResponse(client.events)
-        self.batch_sessions = batch_sessions.AsyncBatchSessionsResourceWithStreamingResponse(client.batch_sessions)
         self.task = task.AsyncTaskResourceWithStreamingResponse(client.task)
+        self.identities = identities.AsyncIdentitiesResourceWithStreamingResponse(client.identities)
 
 
 Client = Anchorbrowser

{anchorbrowser-0.3.13 → anchorbrowser-0.4.0}/src/anchorbrowser/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "anchorbrowser"
-__version__ = "0.3.13"  # x-release-please-version
+__version__ = "0.4.0"  # x-release-please-version

{anchorbrowser-0.3.13 → anchorbrowser-0.4.0}/src/anchorbrowser/resources/__init__.py

@@ -48,13 +48,13 @@ from .extensions import (
     ExtensionsResourceWithStreamingResponse,
     AsyncExtensionsResourceWithStreamingResponse,
 )
-from .batch_sessions import (
-    BatchSessionsResource,
-    AsyncBatchSessionsResource,
-    BatchSessionsResourceWithRawResponse,
-    AsyncBatchSessionsResourceWithRawResponse,
-    BatchSessionsResourceWithStreamingResponse,
-    AsyncBatchSessionsResourceWithStreamingResponse,
+from .identities import (
+    IdentitiesResource,
+    AsyncIdentitiesResource,
+    IdentitiesResourceWithRawResponse,
+    AsyncIdentitiesResourceWithRawResponse,
+    IdentitiesResourceWithStreamingResponse,
+    AsyncIdentitiesResourceWithStreamingResponse,
 )
 
 __all__ = [
@@ -88,16 +88,16 @@ __all__ = [
     "AsyncEventsResourceWithRawResponse",
     "EventsResourceWithStreamingResponse",
     "AsyncEventsResourceWithStreamingResponse",
-    "BatchSessionsResource",
-    "AsyncBatchSessionsResource",
-    "BatchSessionsResourceWithRawResponse",
-    "AsyncBatchSessionsResourceWithRawResponse",
-    "BatchSessionsResourceWithStreamingResponse",
-    "AsyncBatchSessionsResourceWithStreamingResponse",
     "TaskResource",
     "AsyncTaskResource",
     "TaskResourceWithRawResponse",
     "AsyncTaskResourceWithRawResponse",
     "TaskResourceWithStreamingResponse",
     "AsyncTaskResourceWithStreamingResponse",
+    "IdentitiesResource",
+    "AsyncIdentitiesResource",
+    "IdentitiesResourceWithRawResponse",
+    "AsyncIdentitiesResourceWithRawResponse",
+    "IdentitiesResourceWithStreamingResponse",
+    "AsyncIdentitiesResourceWithStreamingResponse",
 ]

anchorbrowser-0.4.0/src/anchorbrowser/resources/identities.py

@@ -0,0 +1,163 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from .._types import Body, Query, Headers, NotGiven, not_given
+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.identity_retrieve_credentials_response import IdentityRetrieveCredentialsResponse
+
+__all__ = ["IdentitiesResource", "AsyncIdentitiesResource"]
+
+
+class IdentitiesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> IdentitiesResourceWithRawResponse:
+        """
+        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/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return IdentitiesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> IdentitiesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return IdentitiesResourceWithStreamingResponse(self)
+
+    def retrieve_credentials(
+        self,
+        identity_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,
+    ) -> IdentityRetrieveCredentialsResponse:
+        """
+        Retrieves the credentials for a specific identity.
+
+        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 identity_id:
+            raise ValueError(f"Expected a non-empty value for `identity_id` but received {identity_id!r}")
+        return self._get(
+            f"/v1/identities/{identity_id}/credentials",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=IdentityRetrieveCredentialsResponse,
+        )
+
+
+class AsyncIdentitiesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncIdentitiesResourceWithRawResponse:
+        """
+        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/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncIdentitiesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncIdentitiesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return AsyncIdentitiesResourceWithStreamingResponse(self)
+
+    async def retrieve_credentials(
+        self,
+        identity_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,
+    ) -> IdentityRetrieveCredentialsResponse:
+        """
+        Retrieves the credentials for a specific identity.
+
+        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 identity_id:
+            raise ValueError(f"Expected a non-empty value for `identity_id` but received {identity_id!r}")
+        return await self._get(
+            f"/v1/identities/{identity_id}/credentials",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=IdentityRetrieveCredentialsResponse,
+        )
+
+
+class IdentitiesResourceWithRawResponse:
+    def __init__(self, identities: IdentitiesResource) -> None:
+        self._identities = identities
+
+        self.retrieve_credentials = to_raw_response_wrapper(
+            identities.retrieve_credentials,
+        )
+
+
+class AsyncIdentitiesResourceWithRawResponse:
+    def __init__(self, identities: AsyncIdentitiesResource) -> None:
+        self._identities = identities
+
+        self.retrieve_credentials = async_to_raw_response_wrapper(
+            identities.retrieve_credentials,
+        )
+
+
+class IdentitiesResourceWithStreamingResponse:
+    def __init__(self, identities: IdentitiesResource) -> None:
+        self._identities = identities
+
+        self.retrieve_credentials = to_streamed_response_wrapper(
+            identities.retrieve_credentials,
+        )
+
+
+class AsyncIdentitiesResourceWithStreamingResponse:
+    def __init__(self, identities: AsyncIdentitiesResource) -> None:
+        self._identities = identities
+
+        self.retrieve_credentials = async_to_streamed_response_wrapper(
+            identities.retrieve_credentials,
+        )

{anchorbrowser-0.3.13 → anchorbrowser-0.4.0}/src/anchorbrowser/types/__init__.py

@@ -30,16 +30,16 @@ from .profile_retrieve_response import ProfileRetrieveResponse as ProfileRetriev
 from .session_retrieve_response import SessionRetrieveResponse as SessionRetrieveResponse
 from .tool_fetch_webpage_params import ToolFetchWebpageParams as ToolFetchWebpageParams
 from .session_upload_file_params import SessionUploadFileParams as SessionUploadFileParams
-from .batch_session_create_params import BatchSessionCreateParams as BatchSessionCreateParams
 from .extension_retrieve_response import ExtensionRetrieveResponse as ExtensionRetrieveResponse
 from .session_list_pages_response import SessionListPagesResponse as SessionListPagesResponse
 from .tool_fetch_webpage_response import ToolFetchWebpageResponse as ToolFetchWebpageResponse
 from .session_drag_and_drop_params import SessionDragAndDropParams as SessionDragAndDropParams
 from .session_upload_file_response import SessionUploadFileResponse as SessionUploadFileResponse
 from .tool_perform_web_task_params import ToolPerformWebTaskParams as ToolPerformWebTaskParams
-from .batch_session_create_response import BatchSessionCreateResponse as BatchSessionCreateResponse
 from .session_drag_and_drop_response import SessionDragAndDropResponse as SessionDragAndDropResponse
 from .tool_perform_web_task_response import ToolPerformWebTaskResponse as ToolPerformWebTaskResponse
 from .tool_screenshot_webpage_params import ToolScreenshotWebpageParams as ToolScreenshotWebpageParams
-from .batch_session_retrieve_response import BatchSessionRetrieveResponse as BatchSessionRetrieveResponse
 from .session_retrieve_downloads_response import SessionRetrieveDownloadsResponse as SessionRetrieveDownloadsResponse
+from .identity_retrieve_credentials_response import (
+    IdentityRetrieveCredentialsResponse as IdentityRetrieveCredentialsResponse,
+)

anchorbrowser-0.4.0/src/anchorbrowser/types/identity_retrieve_credentials_response.py

@@ -0,0 +1,72 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from .._models import BaseModel
+
+__all__ = [
+    "IdentityRetrieveCredentialsResponse",
+    "Credential",
+    "CredentialUsernamePasswordCredentialSchema",
+    "CredentialAuthenticatorCredentialSchema",
+    "CredentialCustomCredentialSchema",
+    "CredentialCustomCredentialSchemaField",
+]
+
+
+class CredentialUsernamePasswordCredentialSchema(BaseModel):
+    password: Optional[str] = None
+    """The password of the credential"""
+
+    type: Optional[Literal["username_password"]] = None
+    """The type of credential"""
+
+    username: Optional[str] = None
+    """The username of the credential"""
+
+
+class CredentialAuthenticatorCredentialSchema(BaseModel):
+    otp: Optional[str] = None
+    """The OTP of the credential"""
+
+    secret: Optional[str] = None
+    """The secret of the credential"""
+
+    type: Optional[Literal["authenticator"]] = None
+    """The type of credential"""
+
+
+class CredentialCustomCredentialSchemaField(BaseModel):
+    name: Optional[str] = None
+    """The name of the field"""
+
+    value: Optional[str] = None
+    """The value of the field"""
+
+
+class CredentialCustomCredentialSchema(BaseModel):
+    fields: Optional[List[CredentialCustomCredentialSchemaField]] = None
+
+    type: Optional[Literal["custom"]] = None
+    """The type of credential"""
+
+
+Credential: TypeAlias = Union[
+    CredentialUsernamePasswordCredentialSchema,
+    CredentialAuthenticatorCredentialSchema,
+    CredentialCustomCredentialSchema,
+]
+
+
+class IdentityRetrieveCredentialsResponse(BaseModel):
+    id: Optional[str] = None
+    """The ID of the identity"""
+
+    credentials: Optional[List[Credential]] = None
+
+    name: Optional[str] = None
+    """The name of the identity"""
+
+    source: Optional[str] = None
+    """The url related to the identity"""

anchorbrowser-0.4.0/tests/api_resources/test_identities.py

@@ -0,0 +1,108 @@
+# 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 anchorbrowser import Anchorbrowser, AsyncAnchorbrowser
+from anchorbrowser.types import IdentityRetrieveCredentialsResponse
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestIdentities:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    def test_method_retrieve_credentials(self, client: Anchorbrowser) -> None:
+        identity = client.identities.retrieve_credentials(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        )
+        assert_matches_type(IdentityRetrieveCredentialsResponse, identity, path=["response"])
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    def test_raw_response_retrieve_credentials(self, client: Anchorbrowser) -> None:
+        response = client.identities.with_raw_response.retrieve_credentials(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        identity = response.parse()
+        assert_matches_type(IdentityRetrieveCredentialsResponse, identity, path=["response"])
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    def test_streaming_response_retrieve_credentials(self, client: Anchorbrowser) -> None:
+        with client.identities.with_streaming_response.retrieve_credentials(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            identity = response.parse()
+            assert_matches_type(IdentityRetrieveCredentialsResponse, identity, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    def test_path_params_retrieve_credentials(self, client: Anchorbrowser) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `identity_id` but received ''"):
+            client.identities.with_raw_response.retrieve_credentials(
+                "",
+            )
+
+
+class TestAsyncIdentities:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    async def test_method_retrieve_credentials(self, async_client: AsyncAnchorbrowser) -> None:
+        identity = await async_client.identities.retrieve_credentials(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        )
+        assert_matches_type(IdentityRetrieveCredentialsResponse, identity, path=["response"])
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    async def test_raw_response_retrieve_credentials(self, async_client: AsyncAnchorbrowser) -> None:
+        response = await async_client.identities.with_raw_response.retrieve_credentials(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        identity = await response.parse()
+        assert_matches_type(IdentityRetrieveCredentialsResponse, identity, path=["response"])
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    async def test_streaming_response_retrieve_credentials(self, async_client: AsyncAnchorbrowser) -> None:
+        async with async_client.identities.with_streaming_response.retrieve_credentials(
+            "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            identity = await response.parse()
+            assert_matches_type(IdentityRetrieveCredentialsResponse, identity, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @pytest.mark.skip(reason="Prism tests are disabled")
+    @parametrize
+    async def test_path_params_retrieve_credentials(self, async_client: AsyncAnchorbrowser) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `identity_id` but received ''"):
+            await async_client.identities.with_raw_response.retrieve_credentials(
+                "",
+            )

anchorbrowser-0.3.13/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.3.13"
-}