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

workos/directory_sync.py

@@ -1,155 +1,435 @@
-import workos
-from workos.utils.request import (
-    RequestHelper,
+from typing import Optional, Protocol
+
+from workos.types.directory_sync.list_filters import (
+    DirectoryGroupListFilters,
+    DirectoryListFilters,
+    DirectoryUserListFilters,
+)
+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,
 )
-from workos.utils.validation import DIRECTORY_SYNC_MODULE, validate_settings
+from workos.types.directory_sync import (
+    DirectoryGroup,
+    Directory,
+    DirectoryUserWithGroups,
+)
+from workos.types.list_resource import ListMetadata, ListPage, WorkOSListResource
 
-RESPONSE_LIMIT = 10
+DirectoryUsersListResource = WorkOSListResource[
+    DirectoryUserWithGroups, DirectoryUserListFilters, ListMetadata
+]
 
+DirectoryGroupsListResource = WorkOSListResource[
+    DirectoryGroup, DirectoryGroupListFilters, ListMetadata
+]
 
-class DirectorySync(object):
-    """Offers methods through the WorkOS Directory Sync service."""
+DirectoriesListResource = WorkOSListResource[
+    Directory, DirectoryListFilters, ListMetadata
+]
 
-    @validate_settings(DIRECTORY_SYNC_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 DirectorySyncModule(Protocol):
+    """Offers methods through the WorkOS Directory Sync service."""
 
     def list_users(
-        self, directory=None, group=None, limit=RESPONSE_LIMIT, before=None, after=None
-    ):
+        self,
+        *,
+        directory_id: Optional[str] = None,
+        group_id: Optional[str] = None,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> SyncOrAsync[DirectoryUsersListResource]:
         """Gets a list of provisioned Users for a Directory.
 
-        Note, either 'directory' or 'group' must be provided.
+        Note, either 'directory_id' or 'group_id' must be provided.
 
-        Args:
-            directory (str): Directory unique identifier.
-            group (str): Directory Group unique identifier.
-            limit (int): Maximum number of records to return.
-            before (str): Pagination cursor to receive records before a provided Directory ID.
-            after (str): Pagination cursor to receive records after a provided Directory ID.
+        Kwargs:
+            directory_id (str): Directory unique identifier. (Optional)
+            group_id (str): Directory Group unique identifier. (Optional)
+            limit (int): Maximum number of records to return. (Optional)
+            before (str): Pagination cursor to receive records before a provided Directory ID. (Optional)
+            after (str): Pagination cursor to receive records after a provided Directory ID. (Optional)
+            order (Literal["asc","desc"]): Sort records in either ascending or descending (default) order by created_at timestamp. (Optional)
 
         Returns:
-            dict: Directory Users response from WorkOS.
+            DirectoryUsersListResource: Directory Users response from WorkOS.
         """
-        params = {"limit": limit, "before": before, "after": after}
-        if group is not None:
-            params["group"] = group
-        if directory is not None:
-            params["directory"] = directory
-        return self.request_helper.request(
-            "directory_users",
-            method=REQUEST_METHOD_GET,
-            params=params,
-            token=workos.api_key,
-        )
+        ...
 
     def list_groups(
-        self, directory=None, user=None, limit=RESPONSE_LIMIT, before=None, after=None
-    ):
+        self,
+        *,
+        directory_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> SyncOrAsync[DirectoryGroupsListResource]:
         """Gets a list of provisioned Groups for a Directory .
 
-        Note, either 'directory' or 'user' must be provided.
+        Note, either 'directory_id' or 'user_id' must be provided.
 
-        Args:
-            directory (str): Directory unique identifier.
-            user (str): Directory User unique identifier.
-            limit (int): Maximum number of records to return.
-            before (str): Pagination cursor to receive records before a provided Directory ID.
-            after (str): Pagination cursor to receive records after a provided Directory ID.
+        Kwargs:
+            directory_id (str): Directory unique identifier. (Optional)
+            user_id (str): Directory User unique identifier. (Optional)
+            limit (int): Maximum number of records to return. (Optional)
+            before (str): Pagination cursor to receive records before a provided Directory ID. (Optional)
+            after (str): Pagination cursor to receive records after a provided Directory ID. (Optional)
+            order (Literal["asc","desc"]): Sort records in either ascending or descending (default) order by created_at timestamp. (Optional)
 
         Returns:
-            dict: Directory Groups response from WorkOS.
+            DirectoryGroupsListResource: Directory Groups response from WorkOS.
         """
-        params = {"limit": limit, "before": before, "after": after}
-        if user is not None:
-            params["user"] = user
-        if directory is not None:
-            params["directory"] = directory
-        return self.request_helper.request(
-            "directory_groups",
-            method=REQUEST_METHOD_GET,
-            params=params,
-            token=workos.api_key,
-        )
+        ...
 
-    def get_user(self, user):
+    def list_directories(
+        self,
+        *,
+        search: Optional[str] = None,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        organization_id: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> SyncOrAsync[DirectoriesListResource]:
+        """Gets details for existing Directories.
+
+        Kwargs:
+            organization_id: ID of an Organization (Optional)
+            search (str): Searchable text for a Directory. (Optional)
+            limit (int): Maximum number of records to return. (Optional)
+            before (str): Pagination cursor to receive records before a provided Directory ID. (Optional)
+            after (str): Pagination cursor to receive records after a provided Directory ID. (Optional)
+            order (Literal["asc","desc"]): Sort records in either ascending or descending (default) order by created_at timestamp. (Optional)
+
+        Returns:
+            DirectoriesListResource: Directories response from WorkOS.
+        """
+        ...
+
+    def get_user(self, user_id: str) -> SyncOrAsync[DirectoryUserWithGroups]:
         """Gets details for a single provisioned Directory User.
 
         Args:
-            user (str): Directory User unique identifier.
+            user_id (str): Directory User unique identifier.
 
         Returns:
-            dict: Directory User response from WorkOS.
+            DirectoryUserWithGroups: Directory User response from WorkOS.
         """
-        return self.request_helper.request(
-            "directory_users/{user}".format(user=user),
-            method=REQUEST_METHOD_GET,
-            token=workos.api_key,
-        )
+        ...
 
-    def get_group(self, group):
+    def get_group(self, group_id: str) -> SyncOrAsync[DirectoryGroup]:
         """Gets details for a single provisioned Directory Group.
 
         Args:
-            group (str): Directory Group unique identifier.
+            group_id (str): Directory Group unique identifier.
 
         Returns:
-            dict: Directory Group response from WorkOS.
+            DirectoryGroup: Directory Group response from WorkOS.
         """
-        return self.request_helper.request(
-            "directory_groups/{group}".format(group=group),
-            method=REQUEST_METHOD_GET,
-            token=workos.api_key,
-        )
+        ...
 
-    def list_directories(
-        self, domain=None, search=None, limit=RESPONSE_LIMIT, before=None, after=None
-    ):
-        """Gets details for existing Directories.
+    def get_directory(self, directory_id: str) -> SyncOrAsync[Directory]:
+        """Gets details for a single Directory
 
         Args:
-            domain (str): Domain of a Directory. (Optional)
-            search (str): Searchable text for a Directory. (Optional)
-            limit (int): Maximum number of records to return. (Optional)
-            before (str): Pagination cursor to receive records before a provided Directory ID. (Optional)
-            after (str): Pagination cursor to receive records after a provided Directory ID. (Optional)
+            directory_id (str): Directory unique identifier.
 
         Returns:
-            dict: Directories response from WorkOS.
+            Directory: Directory response from WorkOS
         """
-        params = {
-            "domain": domain,
-            "search": search,
+        ...
+
+    def delete_directory(self, directory_id: str) -> SyncOrAsync[None]:
+        """Delete one existing Directory.
+
+        Args:
+            directory_id (str): Directory unique identifier.
+
+        Returns:
+            None
+        """
+        ...
+
+
+class DirectorySync(DirectorySyncModule):
+    _http_client: SyncHTTPClient
+
+    def __init__(self, http_client: SyncHTTPClient) -> None:
+        self._http_client = http_client
+
+    def list_users(
+        self,
+        *,
+        directory_id: Optional[str] = None,
+        group_id: Optional[str] = None,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> DirectoryUsersListResource:
+
+        list_params: DirectoryUserListFilters = {
+            "limit": limit,
+            "before": before,
+            "after": after,
+            "order": order,
+        }
+
+        if group_id is not None:
+            list_params["group"] = group_id
+        if directory_id is not None:
+            list_params["directory"] = directory_id
+
+        response = self._http_client.request(
+            "directory_users",
+            method=REQUEST_METHOD_GET,
+            params=list_params,
+        )
+
+        return WorkOSListResource(
+            list_method=self.list_users,
+            list_args=list_params,
+            **ListPage[DirectoryUserWithGroups](**response).model_dump(),
+        )
+
+    def list_groups(
+        self,
+        *,
+        directory_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> DirectoryGroupsListResource:
+        list_params: DirectoryGroupListFilters = {
+            "limit": limit,
+            "before": before,
+            "after": after,
+            "order": order,
+        }
+
+        if user_id is not None:
+            list_params["user"] = user_id
+        if directory_id is not None:
+            list_params["directory"] = directory_id
+
+        response = self._http_client.request(
+            "directory_groups",
+            method=REQUEST_METHOD_GET,
+            params=list_params,
+        )
+
+        return WorkOSListResource[
+            DirectoryGroup, DirectoryGroupListFilters, ListMetadata
+        ](
+            list_method=self.list_groups,
+            list_args=list_params,
+            **ListPage[DirectoryGroup](**response).model_dump(),
+        )
+
+    def get_user(self, user_id: str) -> DirectoryUserWithGroups:
+        response = self._http_client.request(
+            "directory_users/{user}".format(user=user_id),
+            method=REQUEST_METHOD_GET,
+        )
+
+        return DirectoryUserWithGroups.model_validate(response)
+
+    def get_group(self, group_id: str) -> DirectoryGroup:
+        response = self._http_client.request(
+            "directory_groups/{group}".format(group=group_id),
+            method=REQUEST_METHOD_GET,
+        )
+        return DirectoryGroup.model_validate(response)
+
+    def get_directory(self, directory_id: str) -> Directory:
+        response = self._http_client.request(
+            "directories/{directory}".format(directory=directory_id),
+            method=REQUEST_METHOD_GET,
+        )
+
+        return Directory.model_validate(response)
+
+    def list_directories(
+        self,
+        *,
+        search: Optional[str] = None,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        organization_id: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> DirectoriesListResource:
+        list_params: DirectoryListFilters = {
             "limit": limit,
             "before": before,
             "after": after,
+            "order": order,
+            "organization_id": organization_id,
+            "search": search,
         }
-        return self.request_helper.request(
+
+        response = self._http_client.request(
             "directories",
             method=REQUEST_METHOD_GET,
-            params=params,
-            token=workos.api_key,
+            params=list_params,
+        )
+        return WorkOSListResource[Directory, DirectoryListFilters, ListMetadata](
+            list_method=self.list_directories,
+            list_args=list_params,
+            **ListPage[Directory](**response).model_dump(),
         )
 
-    def delete_directory(self, directory):
-        """Delete one existing Directory.
+    def delete_directory(self, directory_id: str) -> None:
+        self._http_client.request(
+            "directories/{directory}".format(directory=directory_id),
+            method=REQUEST_METHOD_DELETE,
+        )
 
-        Args:
-            directory (str): The ID of the directory to be deleted. (Required)
 
-        Returns:
-            dict: Directories response from WorkOS.
-        """
-        return self.request_helper.request(
-            "directories/{directory}".format(directory=directory),
+class AsyncDirectorySync(DirectorySyncModule):
+    """Offers methods through the WorkOS Directory Sync service."""
+
+    _http_client: AsyncHTTPClient
+
+    def __init__(self, http_client: AsyncHTTPClient):
+        self._http_client = http_client
+
+    async def list_users(
+        self,
+        *,
+        directory_id: Optional[str] = None,
+        group_id: Optional[str] = None,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> DirectoryUsersListResource:
+
+        list_params: DirectoryUserListFilters = {
+            "limit": limit,
+            "before": before,
+            "after": after,
+            "order": order,
+        }
+
+        if group_id is not None:
+            list_params["group"] = group_id
+        if directory_id is not None:
+            list_params["directory"] = directory_id
+
+        response = await self._http_client.request(
+            "directory_users",
+            method=REQUEST_METHOD_GET,
+            params=list_params,
+        )
+
+        return WorkOSListResource(
+            list_method=self.list_users,
+            list_args=list_params,
+            **ListPage[DirectoryUserWithGroups](**response).model_dump(),
+        )
+
+    async def list_groups(
+        self,
+        *,
+        directory_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> DirectoryGroupsListResource:
+        list_params: DirectoryGroupListFilters = {
+            "limit": limit,
+            "before": before,
+            "after": after,
+            "order": order,
+        }
+        if user_id is not None:
+            list_params["user"] = user_id
+        if directory_id is not None:
+            list_params["directory"] = directory_id
+
+        response = await self._http_client.request(
+            "directory_groups",
+            method=REQUEST_METHOD_GET,
+            params=list_params,
+        )
+
+        return WorkOSListResource[
+            DirectoryGroup, DirectoryGroupListFilters, ListMetadata
+        ](
+            list_method=self.list_groups,
+            list_args=list_params,
+            **ListPage[DirectoryGroup](**response).model_dump(),
+        )
+
+    async def get_user(self, user_id: str) -> DirectoryUserWithGroups:
+        response = await self._http_client.request(
+            "directory_users/{user}".format(user=user_id),
+            method=REQUEST_METHOD_GET,
+        )
+
+        return DirectoryUserWithGroups.model_validate(response)
+
+    async def get_group(self, group_id: str) -> DirectoryGroup:
+        response = await self._http_client.request(
+            "directory_groups/{group}".format(group=group_id),
+            method=REQUEST_METHOD_GET,
+        )
+        return DirectoryGroup.model_validate(response)
+
+    async def get_directory(self, directory_id: str) -> Directory:
+        response = await self._http_client.request(
+            "directories/{directory}".format(directory=directory_id),
+            method=REQUEST_METHOD_GET,
+        )
+
+        return Directory.model_validate(response)
+
+    async def list_directories(
+        self,
+        *,
+        search: Optional[str] = None,
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        organization_id: Optional[str] = None,
+        order: PaginationOrder = "desc",
+    ) -> DirectoriesListResource:
+        list_params: DirectoryListFilters = {
+            "organization_id": organization_id,
+            "search": search,
+            "limit": limit,
+            "before": before,
+            "after": after,
+            "order": order,
+        }
+
+        response = await self._http_client.request(
+            "directories",
+            method=REQUEST_METHOD_GET,
+            params=list_params,
+        )
+        return WorkOSListResource[Directory, DirectoryListFilters, ListMetadata](
+            list_method=self.list_directories,
+            list_args=list_params,
+            **ListPage[Directory](**response).model_dump(),
+        )
+
+    async def delete_directory(self, directory_id: str) -> None:
+        await self._http_client.request(
+            "directories/{directory}".format(directory=directory_id),
             method=REQUEST_METHOD_DELETE,
-            token=workos.api_key,
         )

workos/events.py

@@ -0,0 +1,111 @@
+from typing import Optional, Protocol, Sequence
+
+from workos.types.events.list_filters import EventsListFilters
+from workos.typing.sync_or_async import SyncOrAsync
+from workos.utils.request_helper import DEFAULT_LIST_RESPONSE_LIMIT, REQUEST_METHOD_GET
+from workos.types.events import Event, EventType
+from workos.utils.http_client import AsyncHTTPClient, SyncHTTPClient
+from workos.types.list_resource import ListAfterMetadata, ListPage, WorkOSListResource
+
+
+EventsListResource = WorkOSListResource[Event, EventsListFilters, ListAfterMetadata]
+
+
+class EventsModule(Protocol):
+    """Offers methods through the WorkOS Events service."""
+
+    def list_events(
+        self,
+        *,
+        events: Sequence[EventType],
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        organization_id: Optional[str] = None,
+        after: Optional[str] = None,
+        range_start: Optional[str] = None,
+        range_end: Optional[str] = None,
+    ) -> SyncOrAsync[EventsListResource]:
+        """Gets a list of Events.
+
+        Kwargs:
+            events (Sequence[EventType]): Filter to only return events of particular types.
+            limit (int): Maximum number of records to return. (Optional)
+            organization_id (str): Organization ID limits scope of events to a single organization. (Optional)
+            after (str): Pagination cursor to receive records after a provided Event ID. (Optional)
+            range_start (str): Date range start for stream of events. (Optional)
+            range_end (str): Date range end for stream of events. (Optional)
+
+        Returns:
+            EventsListResource: Events response from WorkOS.
+        """
+        ...
+
+
+class Events(EventsModule):
+    _http_client: SyncHTTPClient
+
+    def __init__(self, http_client: SyncHTTPClient):
+        self._http_client = http_client
+
+    def list_events(
+        self,
+        *,
+        events: Sequence[EventType],
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        organization_id: Optional[str] = None,
+        after: Optional[str] = None,
+        range_start: Optional[str] = None,
+        range_end: Optional[str] = None,
+    ) -> EventsListResource:
+        params: EventsListFilters = {
+            "events": events,
+            "limit": limit,
+            "after": after,
+            "organization_id": organization_id,
+            "range_start": range_start,
+            "range_end": range_end,
+        }
+
+        response = self._http_client.request(
+            "events", method=REQUEST_METHOD_GET, params=params
+        )
+        return WorkOSListResource[Event, EventsListFilters, ListAfterMetadata](
+            list_method=self.list_events,
+            list_args=params,
+            **ListPage[Event](**response).model_dump(exclude_unset=True),
+        )
+
+
+class AsyncEvents(EventsModule):
+    _http_client: AsyncHTTPClient
+
+    def __init__(self, http_client: AsyncHTTPClient):
+        self._http_client = http_client
+
+    async def list_events(
+        self,
+        *,
+        events: Sequence[EventType],
+        limit: int = DEFAULT_LIST_RESPONSE_LIMIT,
+        organization_id: Optional[str] = None,
+        after: Optional[str] = None,
+        range_start: Optional[str] = None,
+        range_end: Optional[str] = None,
+    ) -> EventsListResource:
+        params: EventsListFilters = {
+            "events": events,
+            "limit": limit,
+            "after": after,
+            "organization_id": organization_id,
+            "range_start": range_start,
+            "range_end": range_end,
+        }
+
+        response = await self._http_client.request(
+            "events", method=REQUEST_METHOD_GET, params=params
+        )
+
+        return WorkOSListResource[Event, EventsListFilters, ListAfterMetadata](
+            list_method=self.list_events,
+            list_args=params,
+            **ListPage[Event](**response).model_dump(exclude_unset=True),
+        )