prelude-python-sdk 0.1.0__py3-none-any.whl

prelude_python_sdk/resources/watch.py

@@ -0,0 +1,297 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import watch_predict_params, watch_feed_back_params
+from .._types import NOT_GIVEN, Body, Query, Headers, 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.watch_predict_response import WatchPredictResponse
+from ..types.watch_feed_back_response import WatchFeedBackResponse
+
+__all__ = ["WatchResource", "AsyncWatchResource"]
+
+
+class WatchResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> WatchResourceWithRawResponse:
+        """
+        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/prelude-so/python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return WatchResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> WatchResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/prelude-so/python-sdk#with_streaming_response
+        """
+        return WatchResourceWithStreamingResponse(self)
+
+    def feed_back(
+        self,
+        *,
+        feedback: watch_feed_back_params.Feedback,
+        target: watch_feed_back_params.Target,
+        # 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,
+    ) -> WatchFeedBackResponse:
+        """
+        Once the user with a trustworthy phone number demonstrates authentic behavior,
+        call this endpoint to report their authenticity to our systems.
+
+        Args:
+          feedback: You should send a feedback event back to Watch API when your user demonstrates
+              authentic behavior.
+
+          target: The target. Currently this can only be an E.164 formatted phone number.
+
+          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
+        """
+        return self._post(
+            "/v2/watch/feedback",
+            body=maybe_transform(
+                {
+                    "feedback": feedback,
+                    "target": target,
+                },
+                watch_feed_back_params.WatchFeedBackParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=WatchFeedBackResponse,
+        )
+
+    def predict(
+        self,
+        *,
+        target: watch_predict_params.Target,
+        signals: watch_predict_params.Signals | 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,
+    ) -> WatchPredictResponse:
+        """
+        Identify trustworthy phone numbers to mitigate fake traffic or traffic involved
+        in fraud and international revenue share fraud (IRSF) patterns. This endpoint
+        must be implemented in conjunction with the `watch/feedback` endpoint.
+
+        Args:
+          target: The target. Currently this can only be an E.164 formatted phone number.
+
+          signals: It is highly recommended that you provide the signals to increase prediction
+              performance.
+
+          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
+        """
+        return self._post(
+            "/v2/watch/predict",
+            body=maybe_transform(
+                {
+                    "target": target,
+                    "signals": signals,
+                },
+                watch_predict_params.WatchPredictParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=WatchPredictResponse,
+        )
+
+
+class AsyncWatchResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncWatchResourceWithRawResponse:
+        """
+        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/prelude-so/python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return AsyncWatchResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncWatchResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/prelude-so/python-sdk#with_streaming_response
+        """
+        return AsyncWatchResourceWithStreamingResponse(self)
+
+    async def feed_back(
+        self,
+        *,
+        feedback: watch_feed_back_params.Feedback,
+        target: watch_feed_back_params.Target,
+        # 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,
+    ) -> WatchFeedBackResponse:
+        """
+        Once the user with a trustworthy phone number demonstrates authentic behavior,
+        call this endpoint to report their authenticity to our systems.
+
+        Args:
+          feedback: You should send a feedback event back to Watch API when your user demonstrates
+              authentic behavior.
+
+          target: The target. Currently this can only be an E.164 formatted phone number.
+
+          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
+        """
+        return await self._post(
+            "/v2/watch/feedback",
+            body=await async_maybe_transform(
+                {
+                    "feedback": feedback,
+                    "target": target,
+                },
+                watch_feed_back_params.WatchFeedBackParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=WatchFeedBackResponse,
+        )
+
+    async def predict(
+        self,
+        *,
+        target: watch_predict_params.Target,
+        signals: watch_predict_params.Signals | 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,
+    ) -> WatchPredictResponse:
+        """
+        Identify trustworthy phone numbers to mitigate fake traffic or traffic involved
+        in fraud and international revenue share fraud (IRSF) patterns. This endpoint
+        must be implemented in conjunction with the `watch/feedback` endpoint.
+
+        Args:
+          target: The target. Currently this can only be an E.164 formatted phone number.
+
+          signals: It is highly recommended that you provide the signals to increase prediction
+              performance.
+
+          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
+        """
+        return await self._post(
+            "/v2/watch/predict",
+            body=await async_maybe_transform(
+                {
+                    "target": target,
+                    "signals": signals,
+                },
+                watch_predict_params.WatchPredictParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=WatchPredictResponse,
+        )
+
+
+class WatchResourceWithRawResponse:
+    def __init__(self, watch: WatchResource) -> None:
+        self._watch = watch
+
+        self.feed_back = to_raw_response_wrapper(
+            watch.feed_back,
+        )
+        self.predict = to_raw_response_wrapper(
+            watch.predict,
+        )
+
+
+class AsyncWatchResourceWithRawResponse:
+    def __init__(self, watch: AsyncWatchResource) -> None:
+        self._watch = watch
+
+        self.feed_back = async_to_raw_response_wrapper(
+            watch.feed_back,
+        )
+        self.predict = async_to_raw_response_wrapper(
+            watch.predict,
+        )
+
+
+class WatchResourceWithStreamingResponse:
+    def __init__(self, watch: WatchResource) -> None:
+        self._watch = watch
+
+        self.feed_back = to_streamed_response_wrapper(
+            watch.feed_back,
+        )
+        self.predict = to_streamed_response_wrapper(
+            watch.predict,
+        )
+
+
+class AsyncWatchResourceWithStreamingResponse:
+    def __init__(self, watch: AsyncWatchResource) -> None:
+        self._watch = watch
+
+        self.feed_back = async_to_streamed_response_wrapper(
+            watch.feed_back,
+        )
+        self.predict = async_to_streamed_response_wrapper(
+            watch.predict,
+        )

prelude_python_sdk/types/__init__.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .watch_predict_params import WatchPredictParams as WatchPredictParams
+from .watch_feed_back_params import WatchFeedBackParams as WatchFeedBackParams
+from .watch_predict_response import WatchPredictResponse as WatchPredictResponse
+from .watch_feed_back_response import WatchFeedBackResponse as WatchFeedBackResponse
+from .transactional_send_params import TransactionalSendParams as TransactionalSendParams
+from .verification_check_params import VerificationCheckParams as VerificationCheckParams
+from .verification_create_params import VerificationCreateParams as VerificationCreateParams
+from .transactional_send_response import TransactionalSendResponse as TransactionalSendResponse
+from .verification_check_response import VerificationCheckResponse as VerificationCheckResponse
+from .verification_create_response import VerificationCreateResponse as VerificationCreateResponse

prelude_python_sdk/types/transactional_send_params.py

@@ -0,0 +1,41 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["TransactionalSendParams"]
+
+
+class TransactionalSendParams(TypedDict, total=False):
+    template_id: Required[str]
+    """The template identifier."""
+
+    to: Required[str]
+    """The recipient's phone number."""
+
+    callback_url: str
+    """The callback URL."""
+
+    correlation_id: str
+    """A unique, user-defined identifier that will be included in webhook events."""
+
+    expires_at: str
+    """The message expiration date."""
+
+    from_: Annotated[str, PropertyInfo(alias="from")]
+    """The Sender ID."""
+
+    locale: str
+    """
+    A BCP-47 formatted locale string with the language the text message will be sent
+    to. If there's no locale set, the language will be determined by the country
+    code of the phone number. If the language specified doesn't exist, the default
+    set on the template will be used.
+    """
+
+    variables: Dict[str, str]
+    """The variables to be replaced in the template."""

prelude_python_sdk/types/transactional_send_response.py

@@ -0,0 +1,39 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from datetime import datetime
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["TransactionalSendResponse"]
+
+
+class TransactionalSendResponse(BaseModel):
+    id: str
+    """The message identifier."""
+
+    created_at: datetime
+    """The message creation date."""
+
+    expires_at: datetime
+    """The message expiration date."""
+
+    template_id: str
+    """The template identifier."""
+
+    to: str
+    """The recipient's phone number."""
+
+    variables: Dict[str, str]
+    """The variables to be replaced in the template."""
+
+    callback_url: Optional[str] = None
+    """The callback URL."""
+
+    correlation_id: Optional[str] = None
+    """A unique, user-defined identifier that will be included in webhook events."""
+
+    from_: Optional[str] = FieldInfo(alias="from", default=None)
+    """The Sender ID."""

prelude_python_sdk/types/verification_check_params.py

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["VerificationCheckParams", "Target"]
+
+
+class VerificationCheckParams(TypedDict, total=False):
+    code: Required[str]
+    """The OTP code to validate."""
+
+    target: Required[Target]
+    """The target. Currently this can only be an E.164 formatted phone number."""
+
+
+class Target(TypedDict, total=False):
+    type: Required[Literal["phone_number"]]
+    """The type of the target. Currently this can only be "phone_number"."""
+
+    value: Required[str]
+    """An E.164 formatted phone number to verify."""

prelude_python_sdk/types/verification_check_response.py

@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["VerificationCheckResponse", "Metadata"]
+
+
+class Metadata(BaseModel):
+    correlation_id: Optional[str] = None
+
+
+class VerificationCheckResponse(BaseModel):
+    status: Literal["success", "failure", "expired_or_not_found"]
+    """The status of the check."""
+
+    id: Optional[str] = None
+    """The verification identifier."""
+
+    metadata: Optional[Metadata] = None
+    """The metadata for this verification."""
+
+    request_id: Optional[str] = None

prelude_python_sdk/types/verification_create_params.py

@@ -0,0 +1,126 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["VerificationCreateParams", "Target", "Metadata", "Options", "OptionsAppRealm", "Signals"]
+
+
+class VerificationCreateParams(TypedDict, total=False):
+    target: Required[Target]
+    """The target. Currently this can only be an E.164 formatted phone number."""
+
+    dispatch_id: str
+    """The identifier of the dispatch that came from the front-end SDK."""
+
+    metadata: Metadata
+    """The metadata for this verification.
+
+    This object will be returned with every response or webhook sent that refers to
+    this verification.
+    """
+
+    options: Options
+    """Verification options"""
+
+    signals: Signals
+    """The signals used for anti-fraud."""
+
+
+class Target(TypedDict, total=False):
+    type: Required[Literal["phone_number"]]
+    """The type of the target. Currently this can only be "phone_number"."""
+
+    value: Required[str]
+    """An E.164 formatted phone number to verify."""
+
+
+class Metadata(TypedDict, total=False):
+    correlation_id: str
+    """A user-defined identifier to correlate this verification with."""
+
+
+class OptionsAppRealm(TypedDict, total=False):
+    platform: Required[Literal["android"]]
+    """The platform the SMS will be sent to.
+
+    We are currently only supporting "android".
+    """
+
+    value: Required[str]
+    """The Android SMS Retriever API hash code that identifies your app."""
+
+
+class Options(TypedDict, total=False):
+    app_realm: OptionsAppRealm
+    """This allows you to automatically retrieve and fill the OTP code on mobile apps.
+
+    Currently only Android devices are supported.
+    """
+
+    code_size: int
+    """The size of the code generated.
+
+    It should be between 4 and 8. Defaults to the code size specified from the
+    Dashboard.
+    """
+
+    custom_code: str
+    """The custom code to use for OTP verification.
+
+    This feature is only available for compatibility purposes and subject to
+    Prelude’s approval. Contact us to discuss your use case. For more details, refer
+    to [Multi Routing](/concepts/multi-routing).
+    """
+
+    locale: str
+    """
+    A BCP-47 formatted locale string with the language the text message will be sent
+    to. If there's no locale set, the language will be determined by the country
+    code of the phone number. If the language specified doesn't exist, it defaults
+    to US English.
+    """
+
+    sender_id: str
+    """The Sender ID to use for this message.
+
+    The Sender ID needs to be enabled by Prelude.
+    """
+
+    template_id: str
+    """The identifier of a verification settings template.
+
+    It is used to be able to switch behavior for specific use cases. Contact us if
+    you need to use this functionality.
+    """
+
+
+class Signals(TypedDict, total=False):
+    app_version: str
+    """The version of your application."""
+
+    device_id: str
+    """The unique identifier for the user's device.
+
+    For Android, this corresponds to the `ANDROID_ID` and for iOS, this corresponds
+    to the `identifierForVendor`.
+    """
+
+    device_model: str
+    """The model of the user's device."""
+
+    device_platform: Literal["android", "ios", "ipados", "tvos", "web"]
+    """The type of the user's device."""
+
+    ip: str
+    """The IP address of the user's device."""
+
+    is_trusted_user: bool
+    """
+    This signal should provide a higher level of trust, indicating that the user is
+    genuine. For more details, refer to [Signals](/guides/prevent-fraud#signals).
+    """
+
+    os_version: str
+    """The version of the user's device operating system."""

prelude_python_sdk/types/verification_create_response.py

@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["VerificationCreateResponse", "Metadata"]
+
+
+class Metadata(BaseModel):
+    correlation_id: Optional[str] = None
+
+
+class VerificationCreateResponse(BaseModel):
+    id: str
+    """The verification identifier."""
+
+    method: Literal["message"]
+    """The method used for verifying this phone number."""
+
+    status: Literal["success", "retry", "blocked"]
+    """The status of the verification."""
+
+    metadata: Optional[Metadata] = None
+    """The metadata for this verification."""
+
+    request_id: Optional[str] = None

prelude_python_sdk/types/watch_feed_back_params.py

@@ -0,0 +1,34 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["WatchFeedBackParams", "Feedback", "Target"]
+
+
+class WatchFeedBackParams(TypedDict, total=False):
+    feedback: Required[Feedback]
+    """
+    You should send a feedback event back to Watch API when your user demonstrates
+    authentic behavior.
+    """
+
+    target: Required[Target]
+    """The target. Currently this can only be an E.164 formatted phone number."""
+
+
+class Feedback(TypedDict, total=False):
+    type: Required[Literal["CONFIRM_TARGET"]]
+    """
+    `CONFIRM_TARGET` should be sent when you are sure that the user with this target
+    (e.g. phone number) is trustworthy.
+    """
+
+
+class Target(TypedDict, total=False):
+    type: Required[Literal["phone_number"]]
+    """The type of the target. Currently this can only be "phone_number"."""
+
+    value: Required[str]
+    """An E.164 formatted phone number to verify."""

prelude_python_sdk/types/watch_feed_back_response.py

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+
+from .._models import BaseModel
+
+__all__ = ["WatchFeedBackResponse"]
+
+
+class WatchFeedBackResponse(BaseModel):
+    id: str
+    """A unique identifier for your feedback request."""

prelude_python_sdk/types/watch_predict_params.py

@@ -0,0 +1,44 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["WatchPredictParams", "Target", "Signals"]
+
+
+class WatchPredictParams(TypedDict, total=False):
+    target: Required[Target]
+    """The target. Currently this can only be an E.164 formatted phone number."""
+
+    signals: Signals
+    """
+    It is highly recommended that you provide the signals to increase prediction
+    performance.
+    """
+
+
+class Target(TypedDict, total=False):
+    type: Required[Literal["phone_number"]]
+    """The type of the target. Currently this can only be "phone_number"."""
+
+    value: Required[str]
+    """An E.164 formatted phone number to verify."""
+
+
+class Signals(TypedDict, total=False):
+    device_id: str
+    """The unique identifier for the user's device.
+
+    For Android, this corresponds to the `ANDROID_ID` and for iOS, this corresponds
+    to the `identifierForVendor`.
+    """
+
+    device_model: str
+    """The model of the user's device."""
+
+    device_type: str
+    """The type of the user's device."""
+
+    ip: str
+    """The IPv4 address of the user's device"""