studyfetch-sdk 0.1.0a1__py3-none-any.whl

studyfetch_sdk/resources/v1/auth/number_2fa.py

@@ -0,0 +1,457 @@
+# 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, NoneType, NotGiven
+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 ....types.v1.auth import (
+    number_2fa_enable_params,
+    number_2fa_disable_params,
+    number_2fa_send_code_params,
+    number_2fa_regenerate_backup_codes_params,
+)
+
+__all__ = ["Number2faResource", "AsyncNumber2faResource"]
+
+
+class Number2faResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> Number2faResourceWithRawResponse:
+        """
+        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/GoStudyFetchGo/studyfetch-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return Number2faResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> Number2faResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/GoStudyFetchGo/studyfetch-sdk-python#with_streaming_response
+        """
+        return Number2faResourceWithStreamingResponse(self)
+
+    def disable(
+        self,
+        *,
+        password: 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,
+    ) -> None:
+        """
+        Args:
+          password: User password for verification
+
+          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(
+            "/api/v1/auth/2fa/disable",
+            body=maybe_transform({"password": password}, number_2fa_disable_params.Number2faDisableParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def enable(
+        self,
+        *,
+        password: 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,
+    ) -> None:
+        """
+        Args:
+          password: User password for verification
+
+          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(
+            "/api/v1/auth/2fa/enable",
+            body=maybe_transform({"password": password}, number_2fa_enable_params.Number2faEnableParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def get_status(
+        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,
+    ) -> None:
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._get(
+            "/api/v1/auth/2fa/status",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def regenerate_backup_codes(
+        self,
+        *,
+        password: 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,
+    ) -> None:
+        """
+        Args:
+          password: User password for verification
+
+          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(
+            "/api/v1/auth/2fa/regenerate-backup-codes",
+            body=maybe_transform(
+                {"password": password}, number_2fa_regenerate_backup_codes_params.Number2faRegenerateBackupCodesParams
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def send_code(
+        self,
+        *,
+        email: 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,
+    ) -> None:
+        """
+        Args:
+          email: Email to send verification code
+
+          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(
+            "/api/v1/auth/2fa/send-code",
+            body=maybe_transform({"email": email}, number_2fa_send_code_params.Number2faSendCodeParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncNumber2faResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncNumber2faResourceWithRawResponse:
+        """
+        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/GoStudyFetchGo/studyfetch-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncNumber2faResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncNumber2faResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/GoStudyFetchGo/studyfetch-sdk-python#with_streaming_response
+        """
+        return AsyncNumber2faResourceWithStreamingResponse(self)
+
+    async def disable(
+        self,
+        *,
+        password: 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,
+    ) -> None:
+        """
+        Args:
+          password: User password for verification
+
+          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(
+            "/api/v1/auth/2fa/disable",
+            body=await async_maybe_transform({"password": password}, number_2fa_disable_params.Number2faDisableParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    async def enable(
+        self,
+        *,
+        password: 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,
+    ) -> None:
+        """
+        Args:
+          password: User password for verification
+
+          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(
+            "/api/v1/auth/2fa/enable",
+            body=await async_maybe_transform({"password": password}, number_2fa_enable_params.Number2faEnableParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    async def get_status(
+        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,
+    ) -> None:
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._get(
+            "/api/v1/auth/2fa/status",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    async def regenerate_backup_codes(
+        self,
+        *,
+        password: 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,
+    ) -> None:
+        """
+        Args:
+          password: User password for verification
+
+          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(
+            "/api/v1/auth/2fa/regenerate-backup-codes",
+            body=await async_maybe_transform(
+                {"password": password}, number_2fa_regenerate_backup_codes_params.Number2faRegenerateBackupCodesParams
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    async def send_code(
+        self,
+        *,
+        email: 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,
+    ) -> None:
+        """
+        Args:
+          email: Email to send verification code
+
+          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(
+            "/api/v1/auth/2fa/send-code",
+            body=await async_maybe_transform({"email": email}, number_2fa_send_code_params.Number2faSendCodeParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class Number2faResourceWithRawResponse:
+    def __init__(self, number_2fa: Number2faResource) -> None:
+        self._number_2fa = number_2fa
+
+        self.disable = to_raw_response_wrapper(
+            number_2fa.disable,
+        )
+        self.enable = to_raw_response_wrapper(
+            number_2fa.enable,
+        )
+        self.get_status = to_raw_response_wrapper(
+            number_2fa.get_status,
+        )
+        self.regenerate_backup_codes = to_raw_response_wrapper(
+            number_2fa.regenerate_backup_codes,
+        )
+        self.send_code = to_raw_response_wrapper(
+            number_2fa.send_code,
+        )
+
+
+class AsyncNumber2faResourceWithRawResponse:
+    def __init__(self, number_2fa: AsyncNumber2faResource) -> None:
+        self._number_2fa = number_2fa
+
+        self.disable = async_to_raw_response_wrapper(
+            number_2fa.disable,
+        )
+        self.enable = async_to_raw_response_wrapper(
+            number_2fa.enable,
+        )
+        self.get_status = async_to_raw_response_wrapper(
+            number_2fa.get_status,
+        )
+        self.regenerate_backup_codes = async_to_raw_response_wrapper(
+            number_2fa.regenerate_backup_codes,
+        )
+        self.send_code = async_to_raw_response_wrapper(
+            number_2fa.send_code,
+        )
+
+
+class Number2faResourceWithStreamingResponse:
+    def __init__(self, number_2fa: Number2faResource) -> None:
+        self._number_2fa = number_2fa
+
+        self.disable = to_streamed_response_wrapper(
+            number_2fa.disable,
+        )
+        self.enable = to_streamed_response_wrapper(
+            number_2fa.enable,
+        )
+        self.get_status = to_streamed_response_wrapper(
+            number_2fa.get_status,
+        )
+        self.regenerate_backup_codes = to_streamed_response_wrapper(
+            number_2fa.regenerate_backup_codes,
+        )
+        self.send_code = to_streamed_response_wrapper(
+            number_2fa.send_code,
+        )
+
+
+class AsyncNumber2faResourceWithStreamingResponse:
+    def __init__(self, number_2fa: AsyncNumber2faResource) -> None:
+        self._number_2fa = number_2fa
+
+        self.disable = async_to_streamed_response_wrapper(
+            number_2fa.disable,
+        )
+        self.enable = async_to_streamed_response_wrapper(
+            number_2fa.enable,
+        )
+        self.get_status = async_to_streamed_response_wrapper(
+            number_2fa.get_status,
+        )
+        self.regenerate_backup_codes = async_to_streamed_response_wrapper(
+            number_2fa.regenerate_backup_codes,
+        )
+        self.send_code = async_to_streamed_response_wrapper(
+            number_2fa.send_code,
+        )

studyfetch_sdk/resources/v1/auth/organization_invites.py

@@ -0,0 +1,160 @@
+# 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, NoneType, NotGiven
+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__ = ["OrganizationInvitesResource", "AsyncOrganizationInvitesResource"]
+
+
+class OrganizationInvitesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> OrganizationInvitesResourceWithRawResponse:
+        """
+        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/GoStudyFetchGo/studyfetch-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return OrganizationInvitesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> OrganizationInvitesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/GoStudyFetchGo/studyfetch-sdk-python#with_streaming_response
+        """
+        return OrganizationInvitesResourceWithStreamingResponse(self)
+
+    def preview(
+        self,
+        token: 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,
+    ) -> None:
+        """
+        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 token:
+            raise ValueError(f"Expected a non-empty value for `token` but received {token!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._get(
+            f"/api/v1/auth/organization-invites/preview/{token}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncOrganizationInvitesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncOrganizationInvitesResourceWithRawResponse:
+        """
+        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/GoStudyFetchGo/studyfetch-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncOrganizationInvitesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncOrganizationInvitesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/GoStudyFetchGo/studyfetch-sdk-python#with_streaming_response
+        """
+        return AsyncOrganizationInvitesResourceWithStreamingResponse(self)
+
+    async def preview(
+        self,
+        token: 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,
+    ) -> None:
+        """
+        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 token:
+            raise ValueError(f"Expected a non-empty value for `token` but received {token!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._get(
+            f"/api/v1/auth/organization-invites/preview/{token}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class OrganizationInvitesResourceWithRawResponse:
+    def __init__(self, organization_invites: OrganizationInvitesResource) -> None:
+        self._organization_invites = organization_invites
+
+        self.preview = to_raw_response_wrapper(
+            organization_invites.preview,
+        )
+
+
+class AsyncOrganizationInvitesResourceWithRawResponse:
+    def __init__(self, organization_invites: AsyncOrganizationInvitesResource) -> None:
+        self._organization_invites = organization_invites
+
+        self.preview = async_to_raw_response_wrapper(
+            organization_invites.preview,
+        )
+
+
+class OrganizationInvitesResourceWithStreamingResponse:
+    def __init__(self, organization_invites: OrganizationInvitesResource) -> None:
+        self._organization_invites = organization_invites
+
+        self.preview = to_streamed_response_wrapper(
+            organization_invites.preview,
+        )
+
+
+class AsyncOrganizationInvitesResourceWithStreamingResponse:
+    def __init__(self, organization_invites: AsyncOrganizationInvitesResource) -> None:
+        self._organization_invites = organization_invites
+
+        self.preview = async_to_streamed_response_wrapper(
+            organization_invites.preview,
+        )

studyfetch_sdk/resources/v1/chat/__init__.py

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .chat import (
+    ChatResource,
+    AsyncChatResource,
+    ChatResourceWithRawResponse,
+    AsyncChatResourceWithRawResponse,
+    ChatResourceWithStreamingResponse,
+    AsyncChatResourceWithStreamingResponse,
+)
+from .test import (
+    TestResource,
+    AsyncTestResource,
+    TestResourceWithRawResponse,
+    AsyncTestResourceWithRawResponse,
+    TestResourceWithStreamingResponse,
+    AsyncTestResourceWithStreamingResponse,
+)
+from .sessions import (
+    SessionsResource,
+    AsyncSessionsResource,
+    SessionsResourceWithRawResponse,
+    AsyncSessionsResourceWithRawResponse,
+    SessionsResourceWithStreamingResponse,
+    AsyncSessionsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "SessionsResource",
+    "AsyncSessionsResource",
+    "SessionsResourceWithRawResponse",
+    "AsyncSessionsResourceWithRawResponse",
+    "SessionsResourceWithStreamingResponse",
+    "AsyncSessionsResourceWithStreamingResponse",
+    "TestResource",
+    "AsyncTestResource",
+    "TestResourceWithRawResponse",
+    "AsyncTestResourceWithRawResponse",
+    "TestResourceWithStreamingResponse",
+    "AsyncTestResourceWithStreamingResponse",
+    "ChatResource",
+    "AsyncChatResource",
+    "ChatResourceWithRawResponse",
+    "AsyncChatResourceWithRawResponse",
+    "ChatResourceWithStreamingResponse",
+    "AsyncChatResourceWithStreamingResponse",
+]