workos 1.5.1__py3-none-any.whl → 5.38.0__py3-none-any.whl

workos/typing/literals.py

@@ -0,0 +1,32 @@
+from typing import Any, TypeVar, Union
+from typing_extensions import Annotated, LiteralString
+from pydantic import (
+    Field,
+    ValidationError,
+    ValidationInfo,
+    ValidatorFunctionWrapHandler,
+    WrapValidator,
+)
+from workos.typing.untyped_literal import UntypedLiteral
+
+
+def convert_unknown_literal_to_untyped_literal(
+    value: Any,
+    handler: ValidatorFunctionWrapHandler,
+    info: ValidationInfo,
+    # TODO: Find a way to better type, give that the last case in the except block truly can return Any
+) -> Union[LiteralString, UntypedLiteral, Any]:
+    try:
+        return handler(value)
+    except ValidationError as validation_error:
+        if validation_error.errors()[0]["type"] == "literal_error":
+            return handler(UntypedLiteral(value))
+        else:
+            return handler(value)
+
+
+LiteralType = TypeVar("LiteralType", bound=LiteralString)
+LiteralOrUntyped = Annotated[
+    Annotated[Union[LiteralType, UntypedLiteral], Field(union_mode="left_to_right")],
+    WrapValidator(convert_unknown_literal_to_untyped_literal),
+]

workos/typing/sync_or_async.py

@@ -0,0 +1,5 @@
+from typing import Awaitable, TypeVar, Union
+
+
+T = TypeVar("T")
+SyncOrAsync = Union[T, Awaitable[T]]

workos/typing/untyped_literal.py

@@ -0,0 +1,37 @@
+from typing import Any
+from pydantic_core import CoreSchema, core_schema
+from pydantic import GetCoreSchemaHandler
+
+
+class UntypedLiteral(str):
+    def __new__(cls, value: str) -> "UntypedLiteral":
+        return super().__new__(cls, f"Untyped[{value}]")
+
+    @classmethod
+    def validate_untyped_literal(cls, value: Any) -> Any:
+        if isinstance(value, UntypedLiteral):
+            return value
+        else:
+            # TODO: Should this raise an error that translates to pydantic's is_instance_of error?
+            raise ValueError("Value is not an instance of UntypedLiteral")
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> CoreSchema:
+        return core_schema.no_info_plain_validator_function(
+            function=cls.validate_untyped_literal,
+        )
+
+
+# TypeGuard doesn't actually work for exhaustiveness checking, but we can return a boolean expression instead
+# https://github.com/python/mypy/issues/15305
+# TODO: see if there is a way to define this as TypeGuard, TypeIs, or bool depending on python version
+# def is_untyped_literal(value: Union[str, UntypedLiteral]) -> TypeGuard[UntypedLiteral]:
+#     return isinstance(value, UntypedLiteral)
+
+
+def is_untyped_literal(value: Any) -> bool:
+    # A helper to detect untyped values from the API (more explainer here)
+    # Does not help with exhaustiveness checking
+    return isinstance(value, UntypedLiteral)

workos/typing/webhooks.py

@@ -0,0 +1,18 @@
+from typing import Any, Dict, Union
+from typing_extensions import Annotated
+from pydantic import Field, TypeAdapter
+from workos.types.webhooks.webhook import Webhook
+from workos.types.workos_model import WorkOSModel
+
+
+# Fall back to untyped Webhook if the event type is not recognized
+class UntypedWebhook(WorkOSModel):
+    id: str
+    event: str
+    data: Dict[str, Any]
+    created_at: str
+
+
+WebhookTypeAdapter: TypeAdapter[Webhook] = TypeAdapter(
+    Annotated[Union[Webhook, UntypedWebhook], Field(union_mode="left_to_right")],
+)