profound 0.1.0__py3-none-any.whl

profound/resources/organizations/categories.py

@@ -0,0 +1,372 @@
+# 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.organizations.category_list_response import CategoryListResponse
+from ...types.organizations.category_tags_response import CategoryTagsResponse
+from ...types.organizations.category_topics_response import CategoryTopicsResponse
+from ...types.organizations.category_prompts_response import CategoryPromptsResponse
+
+__all__ = ["CategoriesResource", "AsyncCategoriesResource"]
+
+
+class CategoriesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> CategoriesResourceWithRawResponse:
+        """
+        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/cooper-square-technologies/profound-python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return CategoriesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CategoriesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/cooper-square-technologies/profound-python-sdk#with_streaming_response
+        """
+        return CategoriesResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        # 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,
+    ) -> CategoryListResponse:
+        """Get the organization categories."""
+        return self._get(
+            "/v1/org/categories",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryListResponse,
+        )
+
+    def prompts(
+        self,
+        category_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,
+    ) -> CategoryPromptsResponse:
+        """
+        Get Category Prompts
+
+        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 category_id:
+            raise ValueError(f"Expected a non-empty value for `category_id` but received {category_id!r}")
+        return self._get(
+            f"/v1/org/categories/{category_id}/prompts",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryPromptsResponse,
+        )
+
+    def tags(
+        self,
+        category_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,
+    ) -> CategoryTagsResponse:
+        """
+        Get the organization tags for a specific category.
+
+        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 category_id:
+            raise ValueError(f"Expected a non-empty value for `category_id` but received {category_id!r}")
+        return self._get(
+            f"/v1/org/categories/{category_id}/tags",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryTagsResponse,
+        )
+
+    def topics(
+        self,
+        category_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,
+    ) -> CategoryTopicsResponse:
+        """
+        Get the organization categories.
+
+        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 category_id:
+            raise ValueError(f"Expected a non-empty value for `category_id` but received {category_id!r}")
+        return self._get(
+            f"/v1/org/categories/{category_id}/topics",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryTopicsResponse,
+        )
+
+
+class AsyncCategoriesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncCategoriesResourceWithRawResponse:
+        """
+        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/cooper-square-technologies/profound-python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return AsyncCategoriesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCategoriesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/cooper-square-technologies/profound-python-sdk#with_streaming_response
+        """
+        return AsyncCategoriesResourceWithStreamingResponse(self)
+
+    async def list(
+        self,
+        *,
+        # 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,
+    ) -> CategoryListResponse:
+        """Get the organization categories."""
+        return await self._get(
+            "/v1/org/categories",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryListResponse,
+        )
+
+    async def prompts(
+        self,
+        category_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,
+    ) -> CategoryPromptsResponse:
+        """
+        Get Category Prompts
+
+        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 category_id:
+            raise ValueError(f"Expected a non-empty value for `category_id` but received {category_id!r}")
+        return await self._get(
+            f"/v1/org/categories/{category_id}/prompts",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryPromptsResponse,
+        )
+
+    async def tags(
+        self,
+        category_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,
+    ) -> CategoryTagsResponse:
+        """
+        Get the organization tags for a specific category.
+
+        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 category_id:
+            raise ValueError(f"Expected a non-empty value for `category_id` but received {category_id!r}")
+        return await self._get(
+            f"/v1/org/categories/{category_id}/tags",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryTagsResponse,
+        )
+
+    async def topics(
+        self,
+        category_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,
+    ) -> CategoryTopicsResponse:
+        """
+        Get the organization categories.
+
+        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 category_id:
+            raise ValueError(f"Expected a non-empty value for `category_id` but received {category_id!r}")
+        return await self._get(
+            f"/v1/org/categories/{category_id}/topics",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=CategoryTopicsResponse,
+        )
+
+
+class CategoriesResourceWithRawResponse:
+    def __init__(self, categories: CategoriesResource) -> None:
+        self._categories = categories
+
+        self.list = to_raw_response_wrapper(
+            categories.list,
+        )
+        self.prompts = to_raw_response_wrapper(
+            categories.prompts,
+        )
+        self.tags = to_raw_response_wrapper(
+            categories.tags,
+        )
+        self.topics = to_raw_response_wrapper(
+            categories.topics,
+        )
+
+
+class AsyncCategoriesResourceWithRawResponse:
+    def __init__(self, categories: AsyncCategoriesResource) -> None:
+        self._categories = categories
+
+        self.list = async_to_raw_response_wrapper(
+            categories.list,
+        )
+        self.prompts = async_to_raw_response_wrapper(
+            categories.prompts,
+        )
+        self.tags = async_to_raw_response_wrapper(
+            categories.tags,
+        )
+        self.topics = async_to_raw_response_wrapper(
+            categories.topics,
+        )
+
+
+class CategoriesResourceWithStreamingResponse:
+    def __init__(self, categories: CategoriesResource) -> None:
+        self._categories = categories
+
+        self.list = to_streamed_response_wrapper(
+            categories.list,
+        )
+        self.prompts = to_streamed_response_wrapper(
+            categories.prompts,
+        )
+        self.tags = to_streamed_response_wrapper(
+            categories.tags,
+        )
+        self.topics = to_streamed_response_wrapper(
+            categories.topics,
+        )
+
+
+class AsyncCategoriesResourceWithStreamingResponse:
+    def __init__(self, categories: AsyncCategoriesResource) -> None:
+        self._categories = categories
+
+        self.list = async_to_streamed_response_wrapper(
+            categories.list,
+        )
+        self.prompts = async_to_streamed_response_wrapper(
+            categories.prompts,
+        )
+        self.tags = async_to_streamed_response_wrapper(
+            categories.tags,
+        )
+        self.topics = async_to_streamed_response_wrapper(
+            categories.topics,
+        )

profound/resources/organizations/organizations.py

@@ -0,0 +1,269 @@
+# 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 .categories import (
+    CategoriesResource,
+    AsyncCategoriesResource,
+    CategoriesResourceWithRawResponse,
+    AsyncCategoriesResourceWithRawResponse,
+    CategoriesResourceWithStreamingResponse,
+    AsyncCategoriesResourceWithStreamingResponse,
+)
+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.organization_models_response import OrganizationModelsResponse
+from ...types.organization_domains_response import OrganizationDomainsResponse
+from ...types.organization_regions_response import OrganizationRegionsResponse
+
+__all__ = ["OrganizationsResource", "AsyncOrganizationsResource"]
+
+
+class OrganizationsResource(SyncAPIResource):
+    @cached_property
+    def categories(self) -> CategoriesResource:
+        return CategoriesResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> OrganizationsResourceWithRawResponse:
+        """
+        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/cooper-square-technologies/profound-python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return OrganizationsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> OrganizationsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/cooper-square-technologies/profound-python-sdk#with_streaming_response
+        """
+        return OrganizationsResourceWithStreamingResponse(self)
+
+    def domains(
+        self,
+        *,
+        # 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,
+    ) -> OrganizationDomainsResponse:
+        """Get the organization domains."""
+        return self._get(
+            "/v1/org/domains",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=OrganizationDomainsResponse,
+        )
+
+    def models(
+        self,
+        *,
+        # 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,
+    ) -> OrganizationModelsResponse:
+        """Get the organization models."""
+        return self._get(
+            "/v1/org/models",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=OrganizationModelsResponse,
+        )
+
+    def regions(
+        self,
+        *,
+        # 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,
+    ) -> OrganizationRegionsResponse:
+        """Get the organization regions."""
+        return self._get(
+            "/v1/org/regions",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=OrganizationRegionsResponse,
+        )
+
+
+class AsyncOrganizationsResource(AsyncAPIResource):
+    @cached_property
+    def categories(self) -> AsyncCategoriesResource:
+        return AsyncCategoriesResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncOrganizationsResourceWithRawResponse:
+        """
+        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/cooper-square-technologies/profound-python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return AsyncOrganizationsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncOrganizationsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/cooper-square-technologies/profound-python-sdk#with_streaming_response
+        """
+        return AsyncOrganizationsResourceWithStreamingResponse(self)
+
+    async def domains(
+        self,
+        *,
+        # 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,
+    ) -> OrganizationDomainsResponse:
+        """Get the organization domains."""
+        return await self._get(
+            "/v1/org/domains",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=OrganizationDomainsResponse,
+        )
+
+    async def models(
+        self,
+        *,
+        # 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,
+    ) -> OrganizationModelsResponse:
+        """Get the organization models."""
+        return await self._get(
+            "/v1/org/models",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=OrganizationModelsResponse,
+        )
+
+    async def regions(
+        self,
+        *,
+        # 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,
+    ) -> OrganizationRegionsResponse:
+        """Get the organization regions."""
+        return await self._get(
+            "/v1/org/regions",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=OrganizationRegionsResponse,
+        )
+
+
+class OrganizationsResourceWithRawResponse:
+    def __init__(self, organizations: OrganizationsResource) -> None:
+        self._organizations = organizations
+
+        self.domains = to_raw_response_wrapper(
+            organizations.domains,
+        )
+        self.models = to_raw_response_wrapper(
+            organizations.models,
+        )
+        self.regions = to_raw_response_wrapper(
+            organizations.regions,
+        )
+
+    @cached_property
+    def categories(self) -> CategoriesResourceWithRawResponse:
+        return CategoriesResourceWithRawResponse(self._organizations.categories)
+
+
+class AsyncOrganizationsResourceWithRawResponse:
+    def __init__(self, organizations: AsyncOrganizationsResource) -> None:
+        self._organizations = organizations
+
+        self.domains = async_to_raw_response_wrapper(
+            organizations.domains,
+        )
+        self.models = async_to_raw_response_wrapper(
+            organizations.models,
+        )
+        self.regions = async_to_raw_response_wrapper(
+            organizations.regions,
+        )
+
+    @cached_property
+    def categories(self) -> AsyncCategoriesResourceWithRawResponse:
+        return AsyncCategoriesResourceWithRawResponse(self._organizations.categories)
+
+
+class OrganizationsResourceWithStreamingResponse:
+    def __init__(self, organizations: OrganizationsResource) -> None:
+        self._organizations = organizations
+
+        self.domains = to_streamed_response_wrapper(
+            organizations.domains,
+        )
+        self.models = to_streamed_response_wrapper(
+            organizations.models,
+        )
+        self.regions = to_streamed_response_wrapper(
+            organizations.regions,
+        )
+
+    @cached_property
+    def categories(self) -> CategoriesResourceWithStreamingResponse:
+        return CategoriesResourceWithStreamingResponse(self._organizations.categories)
+
+
+class AsyncOrganizationsResourceWithStreamingResponse:
+    def __init__(self, organizations: AsyncOrganizationsResource) -> None:
+        self._organizations = organizations
+
+        self.domains = async_to_streamed_response_wrapper(
+            organizations.domains,
+        )
+        self.models = async_to_streamed_response_wrapper(
+            organizations.models,
+        )
+        self.regions = async_to_streamed_response_wrapper(
+            organizations.regions,
+        )
+
+    @cached_property
+    def categories(self) -> AsyncCategoriesResourceWithStreamingResponse:
+        return AsyncCategoriesResourceWithStreamingResponse(self._organizations.categories)