mixpeek 0.12.0__py3-none-any.whl → 0.13__py3-none-any.whl

mixpeek/resources/assets/features.py

@@ -1,172 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import httpx
-
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ..._utils import strip_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.grouped_asset_data import GroupedAssetData
-
-__all__ = ["FeaturesResource", "AsyncFeaturesResource"]
-
-
-class FeaturesResource(SyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> FeaturesResourceWithRawResponse:
-        """
-        This property can be used as a prefix for any HTTP method call to return the
-        the raw response object instead of the parsed content.
-
-        For more information, see https://www.github.com/mixpeek/python-client#accessing-raw-response-data-eg-headers
-        """
-        return FeaturesResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> FeaturesResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/mixpeek/python-client#with_streaming_response
-        """
-        return FeaturesResourceWithStreamingResponse(self)
-
-    def list(
-        self,
-        asset_id: str,
-        *,
-        index_id: str | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> GroupedAssetData:
-        """
-        Get asset details including all related features
-
-        Args:
-          index_id: filter by organization
-
-          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 asset_id:
-            raise ValueError(f"Expected a non-empty value for `asset_id` but received {asset_id!r}")
-        extra_headers = {**strip_not_given({"index-id": index_id}), **(extra_headers or {})}
-        return self._get(
-            f"/assets/{asset_id}/features",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=GroupedAssetData,
-        )
-
-
-class AsyncFeaturesResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncFeaturesResourceWithRawResponse:
-        """
-        This property can be used as a prefix for any HTTP method call to return the
-        the raw response object instead of the parsed content.
-
-        For more information, see https://www.github.com/mixpeek/python-client#accessing-raw-response-data-eg-headers
-        """
-        return AsyncFeaturesResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncFeaturesResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/mixpeek/python-client#with_streaming_response
-        """
-        return AsyncFeaturesResourceWithStreamingResponse(self)
-
-    async def list(
-        self,
-        asset_id: str,
-        *,
-        index_id: str | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> GroupedAssetData:
-        """
-        Get asset details including all related features
-
-        Args:
-          index_id: filter by organization
-
-          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 asset_id:
-            raise ValueError(f"Expected a non-empty value for `asset_id` but received {asset_id!r}")
-        extra_headers = {**strip_not_given({"index-id": index_id}), **(extra_headers or {})}
-        return await self._get(
-            f"/assets/{asset_id}/features",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=GroupedAssetData,
-        )
-
-
-class FeaturesResourceWithRawResponse:
-    def __init__(self, features: FeaturesResource) -> None:
-        self._features = features
-
-        self.list = to_raw_response_wrapper(
-            features.list,
-        )
-
-
-class AsyncFeaturesResourceWithRawResponse:
-    def __init__(self, features: AsyncFeaturesResource) -> None:
-        self._features = features
-
-        self.list = async_to_raw_response_wrapper(
-            features.list,
-        )
-
-
-class FeaturesResourceWithStreamingResponse:
-    def __init__(self, features: FeaturesResource) -> None:
-        self._features = features
-
-        self.list = to_streamed_response_wrapper(
-            features.list,
-        )
-
-
-class AsyncFeaturesResourceWithStreamingResponse:
-    def __init__(self, features: AsyncFeaturesResource) -> None:
-        self._features = features
-
-        self.list = async_to_streamed_response_wrapper(
-            features.list,
-        )

mixpeek/resources/collections.py

@@ -1,283 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from typing import Optional
-
-import httpx
-
-from ..types import collection_list_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from .._utils import (
-    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.collection_list_response import CollectionListResponse
-
-__all__ = ["CollectionsResource", "AsyncCollectionsResource"]
-
-
-class CollectionsResource(SyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> CollectionsResourceWithRawResponse:
-        """
-        This property can be used as a prefix for any HTTP method call to return the
-        the raw response object instead of the parsed content.
-
-        For more information, see https://www.github.com/mixpeek/python-client#accessing-raw-response-data-eg-headers
-        """
-        return CollectionsResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> CollectionsResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/mixpeek/python-client#with_streaming_response
-        """
-        return CollectionsResourceWithStreamingResponse(self)
-
-    def list(
-        self,
-        *,
-        page: Optional[int] | NotGiven = NOT_GIVEN,
-        page_size: int | NotGiven = NOT_GIVEN,
-        index_id: str | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> CollectionListResponse:
-        """
-        List Collections
-
-        Args:
-          index_id: filter by organization
-
-          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({"index-id": index_id}), **(extra_headers or {})}
-        return self._get(
-            "/collections",
-            options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=maybe_transform(
-                    {
-                        "page": page,
-                        "page_size": page_size,
-                    },
-                    collection_list_params.CollectionListParams,
-                ),
-            ),
-            cast_to=CollectionListResponse,
-        )
-
-    def delete(
-        self,
-        collection_id: str,
-        *,
-        index_id: str | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> object:
-        """
-        Delete Collection
-
-        Args:
-          index_id: filter by organization
-
-          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 collection_id:
-            raise ValueError(f"Expected a non-empty value for `collection_id` but received {collection_id!r}")
-        extra_headers = {**strip_not_given({"index-id": index_id}), **(extra_headers or {})}
-        return self._delete(
-            f"/collections/{collection_id}",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=object,
-        )
-
-
-class AsyncCollectionsResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncCollectionsResourceWithRawResponse:
-        """
-        This property can be used as a prefix for any HTTP method call to return the
-        the raw response object instead of the parsed content.
-
-        For more information, see https://www.github.com/mixpeek/python-client#accessing-raw-response-data-eg-headers
-        """
-        return AsyncCollectionsResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncCollectionsResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/mixpeek/python-client#with_streaming_response
-        """
-        return AsyncCollectionsResourceWithStreamingResponse(self)
-
-    async def list(
-        self,
-        *,
-        page: Optional[int] | NotGiven = NOT_GIVEN,
-        page_size: int | NotGiven = NOT_GIVEN,
-        index_id: str | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> CollectionListResponse:
-        """
-        List Collections
-
-        Args:
-          index_id: filter by organization
-
-          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({"index-id": index_id}), **(extra_headers or {})}
-        return await self._get(
-            "/collections",
-            options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=await async_maybe_transform(
-                    {
-                        "page": page,
-                        "page_size": page_size,
-                    },
-                    collection_list_params.CollectionListParams,
-                ),
-            ),
-            cast_to=CollectionListResponse,
-        )
-
-    async def delete(
-        self,
-        collection_id: str,
-        *,
-        index_id: str | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> object:
-        """
-        Delete Collection
-
-        Args:
-          index_id: filter by organization
-
-          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 collection_id:
-            raise ValueError(f"Expected a non-empty value for `collection_id` but received {collection_id!r}")
-        extra_headers = {**strip_not_given({"index-id": index_id}), **(extra_headers or {})}
-        return await self._delete(
-            f"/collections/{collection_id}",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=object,
-        )
-
-
-class CollectionsResourceWithRawResponse:
-    def __init__(self, collections: CollectionsResource) -> None:
-        self._collections = collections
-
-        self.list = to_raw_response_wrapper(
-            collections.list,
-        )
-        self.delete = to_raw_response_wrapper(
-            collections.delete,
-        )
-
-
-class AsyncCollectionsResourceWithRawResponse:
-    def __init__(self, collections: AsyncCollectionsResource) -> None:
-        self._collections = collections
-
-        self.list = async_to_raw_response_wrapper(
-            collections.list,
-        )
-        self.delete = async_to_raw_response_wrapper(
-            collections.delete,
-        )
-
-
-class CollectionsResourceWithStreamingResponse:
-    def __init__(self, collections: CollectionsResource) -> None:
-        self._collections = collections
-
-        self.list = to_streamed_response_wrapper(
-            collections.list,
-        )
-        self.delete = to_streamed_response_wrapper(
-            collections.delete,
-        )
-
-
-class AsyncCollectionsResourceWithStreamingResponse:
-    def __init__(self, collections: AsyncCollectionsResource) -> None:
-        self._collections = collections
-
-        self.list = async_to_streamed_response_wrapper(
-            collections.list,
-        )
-        self.delete = async_to_streamed_response_wrapper(
-            collections.delete,
-        )

mixpeek/resources/entities/__init__.py

@@ -1,47 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from .faces import (
-    FacesResource,
-    AsyncFacesResource,
-    FacesResourceWithRawResponse,
-    AsyncFacesResourceWithRawResponse,
-    FacesResourceWithStreamingResponse,
-    AsyncFacesResourceWithStreamingResponse,
-)
-from .labels import (
-    LabelsResource,
-    AsyncLabelsResource,
-    LabelsResourceWithRawResponse,
-    AsyncLabelsResourceWithRawResponse,
-    LabelsResourceWithStreamingResponse,
-    AsyncLabelsResourceWithStreamingResponse,
-)
-from .entities import (
-    EntitiesResource,
-    AsyncEntitiesResource,
-    EntitiesResourceWithRawResponse,
-    AsyncEntitiesResourceWithRawResponse,
-    EntitiesResourceWithStreamingResponse,
-    AsyncEntitiesResourceWithStreamingResponse,
-)
-
-__all__ = [
-    "FacesResource",
-    "AsyncFacesResource",
-    "FacesResourceWithRawResponse",
-    "AsyncFacesResourceWithRawResponse",
-    "FacesResourceWithStreamingResponse",
-    "AsyncFacesResourceWithStreamingResponse",
-    "LabelsResource",
-    "AsyncLabelsResource",
-    "LabelsResourceWithRawResponse",
-    "AsyncLabelsResourceWithRawResponse",
-    "LabelsResourceWithStreamingResponse",
-    "AsyncLabelsResourceWithStreamingResponse",
-    "EntitiesResource",
-    "AsyncEntitiesResource",
-    "EntitiesResourceWithRawResponse",
-    "AsyncEntitiesResourceWithRawResponse",
-    "EntitiesResourceWithStreamingResponse",
-    "AsyncEntitiesResourceWithStreamingResponse",
-]

mixpeek/resources/entities/entities.py

@@ -1,134 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from .faces import (
-    FacesResource,
-    AsyncFacesResource,
-    FacesResourceWithRawResponse,
-    AsyncFacesResourceWithRawResponse,
-    FacesResourceWithStreamingResponse,
-    AsyncFacesResourceWithStreamingResponse,
-)
-from .labels import (
-    LabelsResource,
-    AsyncLabelsResource,
-    LabelsResourceWithRawResponse,
-    AsyncLabelsResourceWithRawResponse,
-    LabelsResourceWithStreamingResponse,
-    AsyncLabelsResourceWithStreamingResponse,
-)
-from ..._compat import cached_property
-from ..._resource import SyncAPIResource, AsyncAPIResource
-
-__all__ = ["EntitiesResource", "AsyncEntitiesResource"]
-
-
-class EntitiesResource(SyncAPIResource):
-    @cached_property
-    def faces(self) -> FacesResource:
-        return FacesResource(self._client)
-
-    @cached_property
-    def labels(self) -> LabelsResource:
-        return LabelsResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> EntitiesResourceWithRawResponse:
-        """
-        This property can be used as a prefix for any HTTP method call to return the
-        the raw response object instead of the parsed content.
-
-        For more information, see https://www.github.com/mixpeek/python-client#accessing-raw-response-data-eg-headers
-        """
-        return EntitiesResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> EntitiesResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/mixpeek/python-client#with_streaming_response
-        """
-        return EntitiesResourceWithStreamingResponse(self)
-
-
-class AsyncEntitiesResource(AsyncAPIResource):
-    @cached_property
-    def faces(self) -> AsyncFacesResource:
-        return AsyncFacesResource(self._client)
-
-    @cached_property
-    def labels(self) -> AsyncLabelsResource:
-        return AsyncLabelsResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> AsyncEntitiesResourceWithRawResponse:
-        """
-        This property can be used as a prefix for any HTTP method call to return the
-        the raw response object instead of the parsed content.
-
-        For more information, see https://www.github.com/mixpeek/python-client#accessing-raw-response-data-eg-headers
-        """
-        return AsyncEntitiesResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncEntitiesResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/mixpeek/python-client#with_streaming_response
-        """
-        return AsyncEntitiesResourceWithStreamingResponse(self)
-
-
-class EntitiesResourceWithRawResponse:
-    def __init__(self, entities: EntitiesResource) -> None:
-        self._entities = entities
-
-    @cached_property
-    def faces(self) -> FacesResourceWithRawResponse:
-        return FacesResourceWithRawResponse(self._entities.faces)
-
-    @cached_property
-    def labels(self) -> LabelsResourceWithRawResponse:
-        return LabelsResourceWithRawResponse(self._entities.labels)
-
-
-class AsyncEntitiesResourceWithRawResponse:
-    def __init__(self, entities: AsyncEntitiesResource) -> None:
-        self._entities = entities
-
-    @cached_property
-    def faces(self) -> AsyncFacesResourceWithRawResponse:
-        return AsyncFacesResourceWithRawResponse(self._entities.faces)
-
-    @cached_property
-    def labels(self) -> AsyncLabelsResourceWithRawResponse:
-        return AsyncLabelsResourceWithRawResponse(self._entities.labels)
-
-
-class EntitiesResourceWithStreamingResponse:
-    def __init__(self, entities: EntitiesResource) -> None:
-        self._entities = entities
-
-    @cached_property
-    def faces(self) -> FacesResourceWithStreamingResponse:
-        return FacesResourceWithStreamingResponse(self._entities.faces)
-
-    @cached_property
-    def labels(self) -> LabelsResourceWithStreamingResponse:
-        return LabelsResourceWithStreamingResponse(self._entities.labels)
-
-
-class AsyncEntitiesResourceWithStreamingResponse:
-    def __init__(self, entities: AsyncEntitiesResource) -> None:
-        self._entities = entities
-
-    @cached_property
-    def faces(self) -> AsyncFacesResourceWithStreamingResponse:
-        return AsyncFacesResourceWithStreamingResponse(self._entities.faces)
-
-    @cached_property
-    def labels(self) -> AsyncLabelsResourceWithStreamingResponse:
-        return AsyncLabelsResourceWithStreamingResponse(self._entities.labels)