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

workos/organizations.py

@@ -1,37 +1,48 @@
-import workos
-from workos.utils.pagiantion_order import Order
-from workos.utils.request import (
-    RequestHelper,
+from typing import Optional, Protocol, Sequence
+
+from workos.types.feature_flags import FeatureFlag
+from workos.types.feature_flags.list_filters import FeatureFlagListFilters
+from workos.types.metadata import Metadata
+from workos.types.organizations.domain_data_input import DomainDataInput
+from workos.types.organizations.list_filters import OrganizationListFilters
+from workos.types.roles.role import RoleList
+from workos.typing.sync_or_async import SyncOrAsync
+from workos.utils.http_client import AsyncHTTPClient, SyncHTTPClient
+from workos.utils.pagination_order import PaginationOrder
+from workos.utils.request_helper import (
+    DEFAULT_LIST_RESPONSE_LIMIT,
     REQUEST_METHOD_DELETE,
     REQUEST_METHOD_GET,
     REQUEST_METHOD_POST,
     REQUEST_METHOD_PUT,
 )
-from workos.utils.validation import ORGANIZATIONS_MODULE, validate_settings
+from workos.types.organizations import Organization
+from workos.types.list_resource import ListMetadata, ListPage, WorkOSListResource
 
 ORGANIZATIONS_PATH = "organizations"
-RESPONSE_LIMIT = 10
 
 
-class Organizations(object):
-    @validate_settings(ORGANIZATIONS_MODULE)
-    def __init__(self):
-        pass
+OrganizationsListResource = WorkOSListResource[
+    Organization, OrganizationListFilters, ListMetadata
+]
+
+FeatureFlagsListResource = WorkOSListResource[
+    FeatureFlag, FeatureFlagListFilters, ListMetadata
+]
+
 
-    @property
-    def request_helper(self):
-        if not getattr(self, "_request_helper", None):
-            self._request_helper = RequestHelper()
-        return self._request_helper
+class OrganizationsModule(Protocol):
+    """Offers methods through the WorkOS Organizations service."""
 
     def list_organizations(
         self,
-        domains=None,
-        limit=RESPONSE_LIMIT,
-        before=None,
-        after=None,
-        order=None,
-    ):
+        *,
+        domains: Optional[Sequence[str]] = None,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> SyncOrAsync[OrganizationsListResource]:
         """Retrieve a list of organizations that have connections configured within your WorkOS dashboard.
 
         Kwargs:
@@ -39,99 +50,403 @@ class Organizations(object):
             limit (int): Maximum number of records to return. (Optional)
             before (str): Pagination cursor to receive records before a provided Organization ID. (Optional)
             after (str): Pagination cursor to receive records after a provided Organization ID. (Optional)
-            order (Order): Sort records in either ascending or descending order by created_at timestamp.
+            order (Literal["asc","desc"]): Sort records in either ascending or descending (default) order by created_at timestamp. (Optional)
 
         Returns:
-            dict: Organizations response from WorkOS.
+            OrganizationsListResource: Organizations list response from WorkOS.
         """
-        params = {
-            "domains": domains,
+        ...
+
+    def get_organization(self, organization_id: str) -> SyncOrAsync[Organization]:
+        """Gets details for a single Organization
+
+        Args:
+            organization_id (str): Organization's unique identifier
+        Returns:
+            Organization: Organization response from WorkOS
+        """
+        ...
+
+    def get_organization_by_external_id(
+        self, external_id: str
+    ) -> SyncOrAsync[Organization]:
+        """Gets details for a single Organization by external id
+
+        Args:
+            external_id (str): Organization's external id
+
+        Returns:
+            Organization: Organization response from WorkOS
+        """
+        ...
+
+    def create_organization(
+        self,
+        *,
+        name: str,
+        domain_data: Optional[Sequence[DomainDataInput]] = None,
+        idempotency_key: Optional[str] = None,
+        external_id: Optional[str] = None,
+        metadata: Optional[Metadata] = None,
+    ) -> SyncOrAsync[Organization]:
+        """Create an organization
+
+        Kwargs:
+            name (str): A descriptive name for the organization. (Optional)
+            domain_data (Sequence[DomainDataInput]): List of domains that belong to the organization. (Optional)
+            idempotency_key (str): Key to guarantee idempotency across requests. (Optional)
+
+        Returns:
+            Organization: Updated Organization response from WorkOS.
+        """
+        ...
+
+    def update_organization(
+        self,
+        *,
+        organization_id: str,
+        name: Optional[str] = None,
+        domain_data: Optional[Sequence[DomainDataInput]] = None,
+        external_id: Optional[str] = None,
+        metadata: Optional[Metadata] = None,
+    ) -> SyncOrAsync[Organization]:
+        """Update an organization
+
+        Kwargs:
+            organization (str): Organization's unique identifier.
+            name (str): A descriptive name for the organization. (Optional)
+            domain_data (Sequence[DomainDataInput]): List of domains that belong to the organization. (Optional)
+            stripe_customer_id (str): The ID of the Stripe customer associated with the organization. (Optional)
+
+        Returns:
+            Organization: Updated Organization response from WorkOS.
+        """
+        ...
+
+    def delete_organization(self, organization_id: str) -> SyncOrAsync[None]:
+        """Deletes a single Organization
+
+        Args:
+            organization_id (str): Organization unique identifier
+
+        Returns:
+            None
+        """
+        ...
+
+    def list_feature_flags(
+        self,
+        organization_id: str,
+        *,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> SyncOrAsync[FeatureFlagsListResource]:
+        """Retrieve a list of feature flags for an organization
+
+        Args:
+            organization_id (str): Organization's unique identifier
+            limit (int): Maximum number of records to return. (Optional)
+            before (str): Pagination cursor to receive records before a provided Feature Flag ID. (Optional)
+            after (str): Pagination cursor to receive records after a provided Feature Flag ID. (Optional)
+            order (Literal["asc","desc"]): Sort records in either ascending or descending (default) order by created_at timestamp. (Optional)
+
+        Returns:
+            FeatureFlagsListResource: Feature flags list response from WorkOS.
+        """
+        ...
+
+
+class Organizations(OrganizationsModule):
+    _http_client: SyncHTTPClient
+
+    def __init__(self, http_client: SyncHTTPClient):
+        self._http_client = http_client
+
+    def list_organizations(
+        self,
+        *,
+        domains: Optional[Sequence[str]] = None,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> OrganizationsListResource:
+        list_params: OrganizationListFilters = {
             "limit": limit,
             "before": before,
             "after": after,
             "order": order,
+            "domains": domains,
         }
-        if order is not None:
-            if not isinstance(order, Order):
-                raise ValueError("'order' must be of asc or desc order")
-            params["order"] = str(order.value)
-        return self.request_helper.request(
+
+        response = self._http_client.request(
             ORGANIZATIONS_PATH,
             method=REQUEST_METHOD_GET,
-            params=params,
-            token=workos.api_key,
+            params=list_params,
         )
 
-    def get_organization(self, organization):
-        """Gets details for a single Organization
-        Args:
-            organization (str): Organization's unique identifier
-        Returns:
-            dict: Organization response from WorkOS
-        """
-        return self.request_helper.request(
-            "organizations/{organization}".format(organization=organization),
+        return WorkOSListResource[Organization, OrganizationListFilters, ListMetadata](
+            list_method=self.list_organizations,
+            list_args=list_params,
+            **ListPage[Organization](**response).model_dump(),
+        )
+
+    def get_organization(self, organization_id: str) -> Organization:
+        response = self._http_client.request(
+            f"organizations/{organization_id}", method=REQUEST_METHOD_GET
+        )
+
+        return Organization.model_validate(response)
+
+    def get_organization_by_external_id(self, external_id: str) -> Organization:
+        response = self._http_client.request(
+            "organizations/external_id/{external_id}".format(external_id=external_id),
             method=REQUEST_METHOD_GET,
-            token=workos.api_key,
         )
 
-    def create_organization(self, organization):
-        """Create an organization
+        return Organization.model_validate(response)
 
-        Args:
-            organization (dict) - An organization object
-                organization[name] (str) - A unique, descriptive name for the organization
-                organization[allow_profiles_outside_organization] (boolean) - Whether Connections
-                    within the Organization allow profiles that are outside of the Organization's
-                    configured User Email Domains. (Optional)
-                organization[domains] (list) - List of domains that belong to the organization
+    def create_organization(
+        self,
+        *,
+        name: str,
+        domain_data: Optional[Sequence[DomainDataInput]] = None,
+        idempotency_key: Optional[str] = None,
+        external_id: Optional[str] = None,
+        metadata: Optional[Metadata] = None,
+    ) -> Organization:
+        headers = {}
+        if idempotency_key:
+            headers["idempotency-key"] = idempotency_key
 
-        Returns:
-            dict: Created Organization response from WorkOS.
-        """
-        return self.request_helper.request(
+        json = {
+            "name": name,
+            "domain_data": domain_data,
+            "idempotency_key": idempotency_key,
+            "external_id": external_id,
+            "metadata": metadata,
+        }
+
+        response = self._http_client.request(
             ORGANIZATIONS_PATH,
             method=REQUEST_METHOD_POST,
-            params=organization,
-            token=workos.api_key,
+            json=json,
+            headers=headers,
         )
 
+        return Organization.model_validate(response)
+
     def update_organization(
-        self, organization, name, allow_profiles_outside_organization=None, domains=None
-    ):
-        """Update an organization
+        self,
+        *,
+        organization_id: str,
+        name: Optional[str] = None,
+        domain_data: Optional[Sequence[DomainDataInput]] = None,
+        stripe_customer_id: Optional[str] = None,
+        external_id: Optional[str] = None,
+        metadata: Optional[Metadata] = None,
+    ) -> Organization:
+        json = {
+            "name": name,
+            "domain_data": domain_data,
+            "stripe_customer_id": stripe_customer_id,
+            "external_id": external_id,
+            "metadata": metadata,
+        }
 
-        Args:
-            organization(str) - Organization's unique identifier.
-            name (str) - A unique, descriptive name for the organization.
-            allow_profiles_outside_organization (boolean) - Whether Connections
-                within the Organization allow profiles that are outside of the Organization's
-                configured User Email Domains. (Optional)
-            domains (list) - List of domains that belong to the organization. (Optional)
+        response = self._http_client.request(
+            f"organizations/{organization_id}", method=REQUEST_METHOD_PUT, json=json
+        )
 
-        Returns:
-            dict: Updated Organization response from WorkOS.
-        """
-        params = {
-            "name": name,
+        return Organization.model_validate(response)
+
+    def delete_organization(self, organization_id: str) -> None:
+        self._http_client.request(
+            f"organizations/{organization_id}",
+            method=REQUEST_METHOD_DELETE,
+        )
+
+    def list_organization_roles(self, organization_id: str) -> RoleList:
+        response = self._http_client.request(
+            f"organizations/{organization_id}/roles",
+            method=REQUEST_METHOD_GET,
+        )
+
+        return RoleList.model_validate(response)
+
+    def list_feature_flags(
+        self,
+        organization_id: str,
+        *,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> FeatureFlagsListResource:
+        list_params: FeatureFlagListFilters = {
+            "limit": limit,
+            "before": before,
+            "after": after,
+            "order": order,
+        }
+
+        response = self._http_client.request(
+            f"organizations/{organization_id}/feature-flags",
+            method=REQUEST_METHOD_GET,
+            params=list_params,
+        )
+
+        return WorkOSListResource[FeatureFlag, FeatureFlagListFilters, ListMetadata](
+            list_method=self.list_feature_flags,
+            list_args=list_params,
+            **ListPage[FeatureFlag](**response).model_dump(),
+        )
+
+
+class AsyncOrganizations(OrganizationsModule):
+    _http_client: AsyncHTTPClient
+
+    def __init__(self, http_client: AsyncHTTPClient):
+        self._http_client = http_client
+
+    async def list_organizations(
+        self,
+        *,
+        domains: Optional[Sequence[str]] = None,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> OrganizationsListResource:
+        list_params: OrganizationListFilters = {
+            "limit": limit,
+            "before": before,
+            "after": after,
+            "order": order,
             "domains": domains,
-            "allow_profiles_outside_organization": allow_profiles_outside_organization,
         }
-        return self.request_helper.request(
-            "organizations/{organization}".format(organization=organization),
-            method=REQUEST_METHOD_PUT,
-            params=params,
-            token=workos.api_key,
+
+        response = await self._http_client.request(
+            ORGANIZATIONS_PATH,
+            method=REQUEST_METHOD_GET,
+            params=list_params,
         )
 
-    def delete_organization(self, organization):
-        """Deletes a single Organization
+        return WorkOSListResource[Organization, OrganizationListFilters, ListMetadata](
+            list_method=self.list_organizations,
+            list_args=list_params,
+            **ListPage[Organization](**response).model_dump(),
+        )
 
-        Args:
-            organization (str): Organization unique identifier
-        """
-        return self.request_helper.request(
-            "organizations/{organization}".format(organization=organization),
+    async def get_organization(self, organization_id: str) -> Organization:
+        response = await self._http_client.request(
+            f"organizations/{organization_id}", method=REQUEST_METHOD_GET
+        )
+
+        return Organization.model_validate(response)
+
+    async def get_organization_by_external_id(self, external_id: str) -> Organization:
+        response = await self._http_client.request(
+            "organizations/external_id/{external_id}".format(external_id=external_id),
+            method=REQUEST_METHOD_GET,
+        )
+
+        return Organization.model_validate(response)
+
+    async def create_organization(
+        self,
+        *,
+        name: str,
+        domain_data: Optional[Sequence[DomainDataInput]] = None,
+        idempotency_key: Optional[str] = None,
+        external_id: Optional[str] = None,
+        metadata: Optional[Metadata] = None,
+    ) -> Organization:
+        headers = {}
+        if idempotency_key:
+            headers["idempotency-key"] = idempotency_key
+
+        json = {
+            "name": name,
+            "domain_data": domain_data,
+            "idempotency_key": idempotency_key,
+            "external_id": external_id,
+            "metadata": metadata,
+        }
+
+        response = await self._http_client.request(
+            ORGANIZATIONS_PATH,
+            method=REQUEST_METHOD_POST,
+            json=json,
+            headers=headers,
+        )
+
+        return Organization.model_validate(response)
+
+    async def update_organization(
+        self,
+        *,
+        organization_id: str,
+        name: Optional[str] = None,
+        domain_data: Optional[Sequence[DomainDataInput]] = None,
+        stripe_customer_id: Optional[str] = None,
+        external_id: Optional[str] = None,
+        metadata: Optional[Metadata] = None,
+    ) -> Organization:
+        json = {
+            "name": name,
+            "domain_data": domain_data,
+            "stripe_customer_id": stripe_customer_id,
+            "external_id": external_id,
+            "metadata": metadata,
+        }
+
+        response = await self._http_client.request(
+            f"organizations/{organization_id}", method=REQUEST_METHOD_PUT, json=json
+        )
+
+        return Organization.model_validate(response)
+
+    async def delete_organization(self, organization_id: str) -> None:
+        await self._http_client.request(
+            f"organizations/{organization_id}",
             method=REQUEST_METHOD_DELETE,
-            token=workos.api_key,
+        )
+
+    async def list_organization_roles(self, organization_id: str) -> RoleList:
+        response = await self._http_client.request(
+            f"organizations/{organization_id}/roles",
+            method=REQUEST_METHOD_GET,
+        )
+
+        return RoleList.model_validate(response)
+
+    async def list_feature_flags(
+        self,
+        organization_id: str,
+        *,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> FeatureFlagsListResource:
+        list_params: FeatureFlagListFilters = {
+            "limit": limit,
+            "before": before,
+            "after": after,
+            "order": order,
+        }
+
+        response = await self._http_client.request(
+            f"organizations/{organization_id}/feature-flags",
+            method=REQUEST_METHOD_GET,
+            params=list_params,
+        )
+
+        return WorkOSListResource[FeatureFlag, FeatureFlagListFilters, ListMetadata](
+            list_method=self.list_feature_flags,
+            list_args=list_params,
+            **ListPage[FeatureFlag](**response).model_dump(),
         )

workos/passwordless.py

@@ -1,54 +1,46 @@
-import workos
-from workos.utils.request import RequestHelper, REQUEST_METHOD_POST
-from workos.utils.validation import PASSWORDLESS_MODULE, validate_settings
+from typing import Literal, Optional, Protocol
 
+from workos.types.passwordless.passwordless_session_type import PasswordlessSessionType
+from workos.utils.http_client import SyncHTTPClient
+from workos.utils.request_helper import REQUEST_METHOD_POST
+from workos.types.passwordless.passwordless_session import PasswordlessSession
 
-class Passwordless(object):
-    """Offers methods through the WorkOS Passwordless service."""
-
-    @validate_settings(PASSWORDLESS_MODULE)
-    def __init__(self):
-        pass
 
-    @property
-    def request_helper(self):
-        if not getattr(self, "_request_helper", None):
-            self._request_helper = RequestHelper()
-        return self._request_helper
+class PasswordlessModule(Protocol):
+    """Offers methods through the WorkOS Passwordless service."""
 
-    def create_session(self, session_options):
+    def create_session(
+        self,
+        *,
+        email: str,
+        type: PasswordlessSessionType,
+        redirect_uri: Optional[str] = None,
+        state: Optional[str] = None,
+        expires_in: Optional[int] = None,
+    ) -> PasswordlessSession:
         """Create a Passwordless Session.
 
-        Args:
-            session_options (dict) - An session options object
-                session_options[email] (str): The email of the user to authenticate.
-                session_options[redirect_uri] (str): Optional parameter to
-                    specify the redirect endpoint which will handle the callback
-                    from WorkOS. Defaults to the default Redirect URI in the
-                    WorkOS dashboard.
-                session_options[state] (str): Optional parameter that the redirect
-                    URI received from WorkOS will contain. The state parameter
-                    can be used to encode arbitrary information to help
-                    restore application state between redirects.
-                session_options[type] (str): The type of Passwordless Session to
-                    create. Currently, the only supported value is 'MagicLink'.
-                session_options[connection] (str): Optional parameter for the ID of a
-                    specific connection. Can be used to create a Passwordless Session
-                    for a specific connection rather than using the domain from the email
-                    to determine the Organization and Connection.
+        Kwargs:
+            email (str): The email of the user to authenticate.
+            type (PasswordlessSessionType): The type of Passwordless Session to
+                create. Currently, the only supported value is 'MagicLink'.
+            redirect_uri (str): Optional parameter to
+                specify the redirect endpoint which will handle the callback
+                from WorkOS. Defaults to the default Redirect URI in the
+                WorkOS dashboard. (Optional)
+            state (str): Optional parameter that the redirect
+                URI received from WorkOS will contain. The state parameter
+                can be used to encode arbitrary information to help
+                restore application state between redirects. (Optional)
+            expires_in (int): The number of seconds the Passwordless Session should live before expiring.
+                This value must be between 900 (15 minutes) and 86400 (24 hours), inclusive. (Optional)
 
         Returns:
-            dict: Passwordless Session
+            PasswordlessSession: A passwordless session object.
         """
+        ...
 
-        return self.request_helper.request(
-            "passwordless/sessions",
-            method=REQUEST_METHOD_POST,
-            params=session_options,
-            token=workos.api_key,
-        )
-
-    def send_session(self, session_id):
+    def send_session(self, session_id: str) -> Literal[True]:
         """Send a Passwordless Session via email.
 
         Args:
@@ -58,10 +50,42 @@ class Passwordless(object):
         Returns:
             boolean: Returns True
         """
-        self.request_helper.request(
+        ...
+
+
+class Passwordless(PasswordlessModule):
+    _http_client: SyncHTTPClient
+
+    def __init__(self, http_client: SyncHTTPClient):
+        self._http_client = http_client
+
+    def create_session(
+        self,
+        *,
+        email: str,
+        type: PasswordlessSessionType,
+        redirect_uri: Optional[str] = None,
+        state: Optional[str] = None,
+        expires_in: Optional[int] = None,
+    ) -> PasswordlessSession:
+        json = {
+            "email": email,
+            "type": type,
+            "expires_in": expires_in,
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+
+        response = self._http_client.request(
+            "passwordless/sessions", method=REQUEST_METHOD_POST, json=json
+        )
+
+        return PasswordlessSession.model_validate(response)
+
+    def send_session(self, session_id: str) -> Literal[True]:
+        self._http_client.request(
             "passwordless/sessions/{session_id}/send".format(session_id=session_id),
             method=REQUEST_METHOD_POST,
-            token=workos.api_key,
         )
 
         return True