personal_knowledge_library 3.0.0__py3-none-any.whl

knowledge/services/asyncio/search.py

@@ -0,0 +1,439 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2024 Wacom. All rights reserved.
+import asyncio
+from typing import Dict, Any, Optional, List
+
+import orjson
+
+from knowledge.base.language import LocaleCode
+from knowledge.base.search import DocumentSearchResponse, LabelMatchingResponse, VectorDBDocument
+from knowledge.services import (
+    DEFAULT_TIMEOUT,
+    AUTHORIZATION_HEADER_FLAG,
+    APPLICATION_JSON_HEADER,
+    CONTENT_TYPE_HEADER_FLAG,
+    USER_AGENT_HEADER_FLAG,
+)
+from knowledge.services.asyncio.base import AsyncServiceAPIClient, handle_error
+
+
+class AsyncSemanticSearchClient(AsyncServiceAPIClient):
+    """
+    Semantic Search Client
+    ======================
+    Client for searching semantically similar documents and labels.
+
+    Parameters
+    ----------
+    service_url: str
+        Service URL for the client.
+    service_endpoint: str (Default:= 'vector/v1')
+        Service endpoint for the client.
+    """
+
+    def __init__(self, service_url: str, service_endpoint: str = "vector/api/v1"):
+        super().__init__("Async Semantic Search ", service_url, service_endpoint)
+
+    async def retrieve_document_chunks(
+        self, locale: LocaleCode, uri: str, auth_key: Optional[str] = None
+    ) -> List[VectorDBDocument]:
+        """
+        Retrieve document chunks from vector database. The service is automatically chunking the document into
+        smaller parts. The chunks are returned as a list of dictionaries, with metadata and content.
+
+        Parameters
+        ----------
+        locale: LocaleCode
+            Locale
+        uri: str
+            URI of the document
+        auth_key: Optional[str] (Default:= None)
+            If the auth key is set the logged-in user (if any) will be ignored and the auth key will be used.
+
+        Returns
+        -------
+        document: Dict[str, Any]
+            List of document chunks with metadata and content related to the document.
+
+        Raises
+        ------
+        WacomServiceException
+            If the request fails.
+        """
+        if auth_key is None:
+            auth_key, _ = await self.handle_token()
+        url: str = f"{self.service_base_url}documents/"
+
+        headers: Dict[str, str] = {
+            USER_AGENT_HEADER_FLAG: self.user_agent,
+            CONTENT_TYPE_HEADER_FLAG: APPLICATION_JSON_HEADER,
+            AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}",
+        }
+        async with self.__async_session__() as session:
+            async with session.get(
+                url, params={"locale": locale, "uri": uri}, headers=headers, timeout=DEFAULT_TIMEOUT
+            ) as response:
+                if response.ok:
+                    docs: List[VectorDBDocument] = [
+                        VectorDBDocument(vec_doc) for vec_doc in await response.json(loads=orjson.loads)
+                    ]
+                else:
+                    raise await handle_error(
+                        "Failed to retrieve the document.",
+                        response,
+                        headers=headers,
+                        parameters={"locale": locale, "uri": uri},
+                    )
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+        return docs
+
+    async def retrieve_labels(
+        self, locale: LocaleCode, uri: str, auth_key: Optional[str] = None
+    ) -> List[VectorDBDocument]:
+        """
+        Retrieve labels from vector database.
+
+        Parameters
+        ----------
+        locale: LocaleCode
+            Locale
+        uri: str
+            URI of the document
+        auth_key: Optional[str] (Default:= None)
+            If the auth key is set the logged-in user (if any) will be ignored and the auth key will be used.
+
+        Returns
+        -------
+        document: List[VectorDBDocument]
+            List of labels with metadata and content related to the entity with uri.
+
+        Raises
+        ------
+        WacomServiceException
+            If the request fails.
+        """
+        if auth_key is None:
+            auth_key, _ = await self.handle_token()
+        url: str = f"{self.service_base_url}labels/"
+
+        headers: Dict[str, str] = {
+            USER_AGENT_HEADER_FLAG: self.user_agent,
+            CONTENT_TYPE_HEADER_FLAG: APPLICATION_JSON_HEADER,
+            AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}",
+        }
+        async with self.__async_session__() as session:
+            async with session.get(
+                url, params={"locale": locale, "uri": uri}, headers=headers, timeout=DEFAULT_TIMEOUT
+            ) as response:
+                if response.ok:
+                    docs: List[VectorDBDocument] = [
+                        VectorDBDocument(vec_doc) for vec_doc in await response.json(loads=orjson.loads)
+                    ]
+                else:
+                    raise await handle_error(
+                        "Failed to retrieve the document.",
+                        response,
+                        headers=headers,
+                        parameters={"locale": locale, "uri": uri},
+                    )
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+        return docs
+
+    async def count_documents(
+        self, locale: LocaleCode, concept_type: Optional[str] = None, auth_key: Optional[str] = None
+    ) -> int:
+        """
+        Count all documents for a tenant.
+
+        Parameters
+        ----------
+        locale: str
+            Locale
+        concept_type: Optional[str] (Default:= None)
+            Concept type.
+        auth_key: Optional[str] (Default:= None)
+            If the auth key is set the logged-in user (if any) will be ignored and the auth key will be used.
+
+        Returns
+        -------
+        number_of_docs: int
+            Number of documents.
+
+        Raises
+        ------
+        WacomServiceException
+            If the request fails.
+        """
+        if auth_key is None:
+            auth_key, _ = await self.handle_token()
+        url: str = f"{self.service_base_url}documents/count/"
+        headers: Dict[str, str] = {
+            USER_AGENT_HEADER_FLAG: self.user_agent,
+            CONTENT_TYPE_HEADER_FLAG: APPLICATION_JSON_HEADER,
+            AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}",
+        }
+        params: Dict[str, Any] = {"locale": locale}
+        if concept_type:
+            params["concept_type"] = concept_type
+        async with self.__async_session__() as session:
+            async with session.get(url, params=params, headers=headers) as response:
+                if response.ok:
+                    count: int = (await response.json(loads=orjson.loads)).get("count", 0)
+                else:
+                    raise await handle_error(
+                        "Counting documents failed.", response, headers=headers, parameters={"locale": locale}
+                    )
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+        return count
+
+    async def count_documents_filter(
+        self, locale: LocaleCode, filters: Dict[str, Any], auth_key: Optional[str] = None
+    ) -> int:
+        """
+        Count all documents for a tenant using a filter.
+
+        Parameters
+        ----------
+        locale: str
+            Locale
+        filters: Dict[str, Any]
+            Filters for the search
+        auth_key: Optional[str] (Default:= None)
+            If the auth key is set the logged-in user (if any) will be ignored and the auth key will be used.
+
+        Returns
+        -------
+        number_of_docs: int
+            Number of documents.
+
+        Raises
+        ------
+        WacomServiceException
+            If the request fails.
+        """
+        if auth_key is None:
+            auth_key, _ = await self.handle_token()
+        url: str = f"{self.service_base_url}documents/count/filter"
+        headers: Dict[str, str] = {
+            USER_AGENT_HEADER_FLAG: self.user_agent,
+            CONTENT_TYPE_HEADER_FLAG: APPLICATION_JSON_HEADER,
+            AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}",
+        }
+        async with self.__async_session__() as session:
+            async with session.post(url, json={"locale": locale, "filter": filters}, headers=headers) as response:
+                if response.ok:
+                    count: int = (await response.json(loads=orjson.loads)).get("count", 0)
+                else:
+                    raise await handle_error(
+                        "Counting documents failed.",
+                        response,
+                        headers=headers,
+                        parameters={"locale": locale, "filter": filters},
+                    )
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+        return count
+
+    async def count_labels(
+        self, locale: str, concept_type: Optional[str] = None, auth_key: Optional[str] = None
+    ) -> int:
+        """
+        Count all labels entries for a tenant.
+
+        Parameters
+        ----------
+        locale: str
+            Locale
+        concept_type: Optional[str] (Default:= None)
+            Concept type.
+        auth_key: Optional[str] (Default:= None)
+            If auth key is provided, it will be used for the request.
+
+        Returns
+        -------
+        count: int
+            Number of words.
+
+        Raises
+        ------
+        WacomServiceException
+            If the request fails.
+        """
+        if auth_key is None:
+            auth_key, _ = await self.handle_token()
+        url: str = f"{self.service_base_url}labels/count/"
+        headers: Dict[str, str] = {
+            USER_AGENT_HEADER_FLAG: self.user_agent,
+            CONTENT_TYPE_HEADER_FLAG: APPLICATION_JSON_HEADER,
+            AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}",
+        }
+        params: Dict[str, Any] = {"locale": locale}
+        if concept_type:
+            params["concept_type"] = concept_type
+        async with self.__async_session__() as session:
+            async with session.get(url, params=params, headers=headers) as response:
+                if response.ok:
+                    count: int = (await response.json(loads=orjson.loads)).get("count", 0)
+                else:
+                    raise await handle_error(
+                        "Counting labels failed.", response, headers=headers, parameters={"locale": locale}
+                    )
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+        return count
+
+    async def count_labels_filter(
+        self, locale: LocaleCode, filters: Dict[str, Any], auth_key: Optional[str] = None
+    ) -> int:
+        """
+        Count all labels for a tenant using a filter.
+
+        Parameters
+        ----------
+        locale: str
+            Locale
+        filters: Dict[str, Any]
+            Filters for the search
+        auth_key: Optional[str] (Default:= None)
+            If the auth key is set the logged-in user (if any) will be ignored and the auth key will be used.
+
+        Returns
+        -------
+        number_of_docs: int
+            Number of documents.
+
+        Raises
+        ------
+        WacomServiceException
+            If the request fails.
+        """
+        if auth_key is None:
+            auth_key, _ = await self.handle_token()
+        url: str = f"{self.service_base_url}labels/count/filter"
+        headers: Dict[str, str] = {
+            USER_AGENT_HEADER_FLAG: self.user_agent,
+            CONTENT_TYPE_HEADER_FLAG: APPLICATION_JSON_HEADER,
+            AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}",
+        }
+        async with self.__async_session__() as session:
+            async with session.post(url, json={"locale": locale, "filter": filters}, headers=headers) as response:
+                if response.ok:
+                    count: int = (await response.json(loads=orjson.loads)).get("count", 0)
+                else:
+                    raise await handle_error(
+                        "Counting documents failed.",
+                        response,
+                        headers=headers,
+                        parameters={"locale": locale, "filter": filters},
+                    )
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+        return count
+
+    async def document_search(
+        self,
+        query: str,
+        locale: str,
+        filters: Optional[Dict[str, Any]] = None,
+        max_results: int = 10,
+        auth_key: Optional[str] = None,
+    ) -> DocumentSearchResponse:
+        """
+        Async Semantic search.
+
+        Parameters
+        ----------
+        query: str
+            Query text for the search
+        locale: str
+            Locale of the text
+        filters: Optional[Dict[str, Any]] = None
+            Filters for the search
+        max_results: int
+            Maximum number of results
+        auth_key: Optional[str] (Default:= None)
+            If the auth key is set the logged-in user (if any) will be ignored and the auth key will be used.
+
+        Returns
+        -------
+        response: DocumentSearchResponse
+            Search results response.
+
+        Raises
+        ------
+        WacomServiceException
+            If the request fails.
+        """
+        if auth_key is None:
+            auth_key, _ = await self.handle_token()
+        url: str = f"{self.service_base_url}documents/search/"
+        headers: Dict[str, str] = {
+            USER_AGENT_HEADER_FLAG: self.user_agent,
+            CONTENT_TYPE_HEADER_FLAG: APPLICATION_JSON_HEADER,
+            AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}",
+        }
+        params: Dict[str, Any] = {
+            "query": query,
+            "metadata": filters if filters else {},
+            "locale": locale,
+            "max_results": max_results,
+        }
+        async with self.__async_session__() as session:
+            async with session.post(url, headers=headers, json=params) as response:
+                if response.ok:
+                    response_dict: Dict[str, Any] = await response.json(loads=orjson.loads)
+                else:
+                    raise await handle_error("Semantic Search failed.", response, headers=headers, parameters=params)
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+        return DocumentSearchResponse.from_dict(response_dict)
+
+    async def labels_search(
+        self,
+        query: str,
+        locale: str,
+        filters: Optional[Dict[str, Any]] = None,
+        max_results: int = 10,
+        auth_key: Optional[str] = None,
+    ) -> LabelMatchingResponse:
+        """
+        Async search for semantically similar labels.
+
+        Parameters
+        ----------
+        query: str
+            Query text for the search
+        locale: str
+            Locale of the text
+        filters: Optional[Dict[str, Any]] = None
+            Filters for the search
+        max_results: int
+            Maximum number of results
+        auth_key: Optional[str] (Default:= None)
+            If the auth key is set the logged-in user (if any) will be ignored and the auth key will be used.
+
+        Returns
+        -------
+        response: LabelMatchingResponse
+            Search results response.
+        """
+        if auth_key is None:
+            auth_key, _ = await self.handle_token()
+        url: str = f"{self.service_base_url}labels/match/"
+        headers: Dict[str, str] = {
+            USER_AGENT_HEADER_FLAG: self.user_agent,
+            CONTENT_TYPE_HEADER_FLAG: APPLICATION_JSON_HEADER,
+            AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}",
+        }
+        params: Dict[str, Any] = {
+            "query": query,
+            "metadata": filters if filters else {},
+            "locale": locale,
+            "max_results": max_results,
+        }
+        async with self.__async_session__() as session:
+            async with session.post(url, headers=headers, json=params) as response:
+                if response.ok:
+                    response_dict: Dict[str, Any] = await response.json(loads=orjson.loads)
+                else:
+                    raise await handle_error(
+                        "Label fuzzy matching failed.", response, headers=headers, parameters=params
+                    )
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+        return LabelMatchingResponse.from_dict(response_dict)

knowledge/services/asyncio/users.py

@@ -0,0 +1,270 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2024 Wacom. All rights reserved.
+import asyncio
+from datetime import datetime
+from typing import Any, Union, Dict, List, Tuple
+
+import orjson
+
+from knowledge import logger
+from knowledge.services import APPLICATION_JSON_HEADER, EXPIRATION_DATE_TAG
+from knowledge.services.asyncio.base import AsyncServiceAPIClient, handle_error
+from knowledge.services.base import WacomServiceAPIClient
+from knowledge.services.users import (
+    UserRole,
+    USER_AGENT_TAG,
+    TENANT_API_KEY_FLAG,
+    OFFSET_TAG,
+    LIMIT_TAG,
+    User,
+    USER_ID_TAG,
+    EXTERNAL_USER_ID_TAG,
+    FORCE_TAG,
+    ROLES_TAG,
+    META_DATA_TAG,
+    CONTENT_TYPE_FLAG,
+    DEFAULT_TIMEOUT,
+    INTERNAL_USER_ID_TAG,
+)
+
+
+class AsyncUserManagementService(AsyncServiceAPIClient):
+    """
+    Async User-Management Service API
+    ---------------------------------
+    Functionality:
+        - List all users
+        - Create / update / delete users
+
+    Parameters
+    ----------
+    application_name: str
+        Name of the application
+    service_url: str
+        URL of the service
+    service_endpoint: str
+        Base endpoint
+    """
+
+    USER_DETAILS_ENDPOINT: str = f"{WacomServiceAPIClient.USER_ENDPOINT}/internal-id"
+
+    def __init__(
+        self,
+        application_name: str,
+        service_url: str = WacomServiceAPIClient.SERVICE_URL,
+        service_endpoint: str = "graph/v1",
+    ):
+        super().__init__(application_name=application_name, service_url=service_url, service_endpoint=service_endpoint)
+
+    # ------------------------------------------ Users handling --------------------------------------------------------
+
+    async def create_user(
+        self, tenant_key: str, external_id: str, meta_data: Dict[str, str] = None, roles: List[UserRole] = None
+    ) -> Tuple[User, str, str, datetime]:
+        """
+        Creates user for a tenant.
+
+        Parameters
+        ----------
+        tenant_key: str -
+            API key for tenant
+        external_id: str -
+            External id of user identification service.
+        meta_data: Dict[str, str]
+            Meta-data dictionary.
+        roles: List[UserRole]
+            List of roles.
+
+        Returns
+        -------
+        user: User
+            Instance of the user
+        token: str
+            Auth token for user
+        refresh_key: str
+            Refresh token
+        expiration_time: datetime
+            Expiration time
+        Raises
+        ------
+        WacomServiceException
+            If the tenant service returns an error code.
+        """
+        url: str = f"{self.service_base_url}{AsyncUserManagementService.USER_ENDPOINT}"
+        headers: dict = {
+            USER_AGENT_TAG: self.user_agent,
+            TENANT_API_KEY_FLAG: tenant_key,
+            CONTENT_TYPE_FLAG: "application/json",
+        }
+        payload: dict = {
+            EXTERNAL_USER_ID_TAG: external_id,
+            META_DATA_TAG: meta_data if meta_data is not None else {},
+            ROLES_TAG: [r.value for r in roles] if roles is not None else [UserRole.USER.value],
+        }
+        async with self.__async_session__() as session:
+            async with session.post(
+                url, headers=headers, json=payload, timeout=DEFAULT_TIMEOUT, verify_ssl=self.verify_calls
+            ) as response:
+                if response.ok:
+                    results: Dict[str, Union[str, Dict[str, str], List[str]]] = await response.json(loads=orjson.loads)
+                    try:
+                        date_object: datetime = datetime.fromisoformat(results["token"][EXPIRATION_DATE_TAG])
+                    except (TypeError, ValueError) as _:
+                        date_object: datetime = datetime.now()
+                        logger.warning(f'Parsing of expiration date failed. {results["token"][EXPIRATION_DATE_TAG]}')
+
+                else:
+                    raise await handle_error("Failed to create the user.", response, headers=headers, payload=payload)
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+        return (
+            User.parse(results["user"]),
+            results["token"]["accessToken"],
+            results["token"]["refreshToken"],
+            date_object,
+        )
+
+    async def update_user(
+        self,
+        tenant_key: str,
+        internal_id: str,
+        external_id: str,
+        meta_data: Dict[str, str] = None,
+        roles: List[UserRole] = None,
+    ):
+        """Updates user for a tenant.
+
+        Parameters
+        ----------
+        tenant_key: str
+            API key for tenant
+        internal_id: str
+            Internal id of semantic service.
+        external_id: str
+            External id of user identification service.
+        meta_data: Dict[str, str]
+            Meta-data dictionary.
+        roles: List[UserRole]
+            List of roles.
+
+        Raises
+        ------
+        WacomServiceException
+            If the tenant service returns an error code.
+        """
+        url: str = f"{self.service_base_url}{AsyncUserManagementService.USER_ENDPOINT}"
+        headers: Dict[str, str] = {
+            USER_AGENT_TAG: self.user_agent,
+            TENANT_API_KEY_FLAG: tenant_key,
+            CONTENT_TYPE_FLAG: APPLICATION_JSON_HEADER,
+        }
+        payload: Dict[str, str] = {
+            META_DATA_TAG: meta_data if meta_data is not None else {},
+            ROLES_TAG: [r.value for r in roles] if roles is not None else [UserRole.USER.value],
+        }
+        params: Dict[str, str] = {USER_ID_TAG: internal_id, EXTERNAL_USER_ID_TAG: external_id}
+        async with self.__async_session__() as session:
+            async with session.patch(
+                url, headers=headers, json=payload, params=params, timeout=DEFAULT_TIMEOUT, verify_ssl=self.verify_calls
+            ) as response:
+                if not response.ok:
+                    raise await handle_error("Failed to update the user.", response, headers=headers, payload=payload)
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+
+    async def delete_user(self, tenant_key: str, external_id: str, internal_id: str, force: bool = False):
+        """Deletes user from tenant.
+
+        Parameters
+        ----------
+        tenant_key: str
+            API key for tenant
+        external_id: str
+            External id of user identification service.
+        internal_id: str
+            Internal id of user.
+        force: bool
+            If set to true removes all user data including groups and entities.
+
+        Raises
+        ------
+        WacomServiceException
+            If the tenant service returns an error code.
+        """
+        url: str = f"{self.service_base_url}{AsyncUserManagementService.USER_ENDPOINT}"
+        headers: Dict[str, str] = {USER_AGENT_TAG: self.user_agent, TENANT_API_KEY_FLAG: tenant_key}
+        params: Dict[str, str] = {USER_ID_TAG: internal_id, EXTERNAL_USER_ID_TAG: external_id, FORCE_TAG: str(force)}
+        async with self.__async_session__() as session:
+            async with session.delete(
+                url, headers=headers, params=params, timeout=DEFAULT_TIMEOUT, verify_ssl=self.verify_calls
+            ) as response:
+                if not response.ok:
+                    raise await handle_error("Failed to delete the user.", response, headers=headers)
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+
+    async def user_internal_id(self, tenant_key: str, external_id: str) -> str:
+        """User internal id.
+
+        Parameters
+        ----------
+        tenant_key: str
+            API key for tenant
+        external_id: str
+            External id of user
+
+        Returns
+        -------
+        internal_user_id: str
+            Internal id of users
+
+        Raises
+        ------
+        WacomServiceException
+            If the tenant service returns an error code.
+        """
+        url: str = f"{self.service_base_url}{AsyncUserManagementService.USER_DETAILS_ENDPOINT}"
+        headers: dict = {USER_AGENT_TAG: self.user_agent, TENANT_API_KEY_FLAG: tenant_key}
+        parameters: Dict[str, str] = {EXTERNAL_USER_ID_TAG: external_id}
+        async with self.__async_session__() as session:
+            async with session.get(
+                url, headers=headers, params=parameters, timeout=DEFAULT_TIMEOUT, verify_ssl=self.verify_calls
+            ) as response:
+                if response.ok:
+                    response_dict: Dict[str, Any] = await response.json(loads=orjson.loads)
+                else:
+                    raise await handle_error("Failed to get the user.", response, headers=headers)
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+        return response_dict[INTERNAL_USER_ID_TAG]
+
+    async def listing_users(self, tenant_key: str, offset: int = 0, limit: int = 20) -> List[User]:
+        """
+        Listing all users configured for this instance.
+
+        Parameters
+        ----------
+        tenant_key: str
+            API key for tenant
+        offset: int - [optional]
+            Offset value to define starting position in list. [DEFAULT:= 0]
+        limit: int - [optional]
+            Define the limit of the list size. [DEFAULT:= 20]
+
+        Returns
+        -------
+        user: List[User]
+            List of users.
+        """
+        url: str = f"{self.service_base_url}{AsyncUserManagementService.USER_ENDPOINT}"
+        headers: Dict[str, str] = {USER_AGENT_TAG: self.user_agent, TENANT_API_KEY_FLAG: tenant_key}
+        params: Dict[str, str] = {OFFSET_TAG: offset, LIMIT_TAG: limit}
+        async with self.__async_session__() as session:
+            async with session.get(
+                url, headers=headers, params=params, timeout=DEFAULT_TIMEOUT, verify_ssl=self.verify_calls
+            ) as response:
+                if response.ok:
+                    users: List[Dict[str, Any]] = await response.json(loads=orjson.loads)
+                    results: List[User] = []
+                    for u in users:
+                        results.append(User.parse(u))
+                else:
+                    await handle_error("Listing of users failed.", response, headers=headers, parameters=params)
+        await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
+        return results