symphony_bdk_python 2.10.dev0__py3-none-any.whl → 2.11.0b0__py3-none-any.whl

symphony/bdk/core/auth/auth_session.py

@@ -5,10 +5,13 @@ from datetime import datetime, timezone
 import logging
 
 from symphony.bdk.core.auth.exception import AuthInitializationError
+from symphony.bdk.core.auth.jwt_helper import extract_token_claims
+
 
 logger = logging.getLogger(__name__)
 
 EXPIRATION_SAFETY_BUFFER_SECONDS = 5
+SKD_FLAG_NAME = "canUseSimplifiedKeyDelivery"
 
 
 class AuthSession:
@@ -33,7 +36,10 @@ class AuthSession:
         """
         logger.debug("Authenticate")
         self._session_token = await self._authenticator.retrieve_session_token()
-        self._key_manager_token = await self._authenticator.retrieve_key_manager_token()
+        if await self.skd_enabled:
+            self._key_manager_token = ""
+            return
+        self.key_manager_token = await self._authenticator.retrieve_key_manager_token()
 
     @property
     async def session_token(self):
@@ -71,6 +77,10 @@ class AuthSession:
 
         :return: the key manager token
         """
+
+        if await self.skd_enabled:
+            return ""
+
         if self._key_manager_token is None:
             self._key_manager_token = await self._authenticator.retrieve_key_manager_token()
         return self._key_manager_token
@@ -91,6 +101,15 @@ class AuthSession:
         """
         self._key_manager_token = value
 
+    @property
+    async def skd_enabled(self):
+
+        token_data = extract_token_claims(await self.session_token)
+        if not token_data.get(SKD_FLAG_NAME, False):
+            return False
+        return await self._authenticator.agent_version_service.is_skd_supported()
+
+
 
 class OboAuthSession(AuthSession):
     """RSA OBO Authentication session handle to get the OBO session token from.

symphony/bdk/core/auth/bot_authenticator.py

@@ -8,6 +8,7 @@ from symphony.bdk.core.config.model.bdk_bot_config import BdkBotConfig
 from symphony.bdk.core.config.model.bdk_retry_config import BdkRetryConfig
 from symphony.bdk.core.retry import retry
 from symphony.bdk.core.retry.strategy import authentication_retry
+from symphony.bdk.core.service.version.agent_version_service import AgentVersionService
 from symphony.bdk.gen.api_client import ApiClient
 from symphony.bdk.gen.auth_api.certificate_authentication_api import CertificateAuthenticationApi
 from symphony.bdk.gen.login_api.authentication_api import AuthenticationApi
@@ -24,6 +25,7 @@ class BotAuthenticator(ABC):
         self._session_auth_client = session_auth_client
         self._key_manager_auth_client = key_manager_auth_client
         self._retry_config = retry_config
+        self._agent_version_service = None
 
     async def retrieve_session_token(self) -> str:
         """Authenticates and retrieves a new session token.
@@ -59,6 +61,15 @@ class BotAuthenticator(ABC):
         :return: the token as a string
         """
 
+    @property
+    def agent_version_service(self) -> Optional[AgentVersionService]:
+        return self._agent_version_service
+
+    @agent_version_service.setter
+    def agent_version_service(self, agent_version_service: AgentVersionService):
+        self._agent_version_service = agent_version_service
+
+
 
 class BotAuthenticatorRsa(BotAuthenticator):
     """Bot authenticator RSA implementation.

symphony/bdk/core/auth/jwt_helper.py

@@ -83,3 +83,13 @@ def _parse_public_key_from_x509_cert(certificate: str) -> str:
         return public_key.public_bytes(Encoding.PEM, PublicFormat.SubjectPublicKeyInfo).decode()
     except ValueError as exc:
         raise AuthInitializationError("Unable to parse the certificate. Check certificate format.") from exc
+
+
+def extract_token_claims(session_token):
+    try:
+        return jwt.decode(session_token,
+                      algorithms=[JWT_ENCRYPTION_ALGORITHM],
+                      options={"verify_signature": False}
+                      )
+    except DecodeError:
+        return {}

symphony/bdk/core/config/model/bdk_config.py

@@ -30,6 +30,7 @@ class BdkConfig(BdkServerConfig):
         self.datafeed = BdkDatafeedConfig(config.get("datafeed"))
         self.datahose = BdkDatahoseConfig(config.get("datahose"))
         self.retry = BdkRetryConfig(config.get("retry"))
+        self.manifest = config.get("manifest")
 
     def is_bot_configured(self) -> bool:
         """

symphony/bdk/core/service/stream/stream_service.py

@@ -136,31 +136,35 @@ class OboStreamService:
 
     @retry
     async def search_rooms(self, query: V2RoomSearchCriteria, skip: int = 0,
-                           limit: int = 50) -> V3RoomSearchResults:
+                           limit: int = 50, include_non_discoverable=False) -> V3RoomSearchResults:
         """Search for rooms according to the specified criteria.
         Wraps the `Search Rooms V3 <https://developers.symphony.com/restapi/reference/search-rooms-v3>`_ endpoint.
 
         :param query: the search criteria.
         :param skip: number of rooms to skip, defaults to 0.
         :param limit: number of maximum rooms to return. Must be a positive integer that does not exceed 100.
+        :param include_non_discoverable: set to `True` to include rooms not publicly searchable, false by default.
         :return: the rooms matching search criteria.
         """
         return await self._streams_api.v3_room_search_post(query=query, skip=skip, limit=limit,
+                                                           include_non_discoverable=include_non_discoverable,
                                                            session_token=await self._auth_session.session_token)
 
     async def search_all_rooms(self, query: V2RoomSearchCriteria, chunk_size: int = 50,
-                               max_number: int = None) -> AsyncGenerator[V3RoomDetail, None]:
+                               max_number: int = None, include_non_discoverable : bool = False)\
+            -> AsyncGenerator[V3RoomDetail, None]:
         """Search for rooms according to the specified criteria.
         Wraps the `Search Rooms V3 <https://developers.symphony.com/restapi/reference/search-rooms-v3>`_ endpoint.
 
         :param query: the search criteria.
         :param chunk_size: the maximum number of elements to retrieve in one underlying HTTP call.
         :param max_number: the total maximum number of elements to retrieve.
+        :param include_non_discoverable: set to `True` to include rooms not publicly searchable, false by default.
         :return: an asynchronous generator of the rooms matching the search criteria.
         """
 
         async def search_rooms_one_page(skip, limit):
-            result = await self.search_rooms(query, skip, limit)
+            result = await self.search_rooms(query, skip, limit, include_non_discoverable)
             return result.rooms if result.rooms else None
 
         return offset_based_pagination(search_rooms_one_page, chunk_size, max_number)
@@ -346,6 +350,39 @@ class StreamService(OboStreamService):
 
         return offset_based_pagination(list_streams_admin_one_page, chunk_size, max_number)
 
+    @retry
+    async def list_user_streams_admin(self, uid: int, stream_filter: StreamFilter = None, skip: int = 0,
+                                limit: int = 50) -> StreamList:
+        """Retrieve a list of all streams of which a user is a member.
+        Wraps the `User Streams <https://developers.symphony.com/restapi/v20.16/reference#user-streams>`_ endpoint.
+
+        :param uid: the ID of the user.
+        :param stream_filter: the filtering criteria for the streams.
+        :param skip: the number of streams to skip.
+        :param limit: the maximum number of streams to retrieve. Must be less or equal than 1000.
+        :return: the list of streams for the specified user.
+        """
+        return await self._streams_api.v1_admin_user_uid_streams_list_post(
+            uid=uid, filter=stream_filter, skip=skip, limit=limit, session_token=await self._auth_session.session_token
+        )
+
+    async def list_all_user_streams_admin(self, uid: int, stream_filter: StreamFilter = None, chunk_size: int = 50,
+                                    max_number: int = None) -> AsyncGenerator[StreamAttributes, None]:
+        """Retrieves all streams of which a user is a member, handling pagination automatically.
+        Wraps the `User Streams <https://developers.symphony.com/restapi/v20.16/reference#user-streams>`_ endpoint.
+
+        :param uid: the ID of the user.
+        :param stream_filter: the filtering criteria for the streams.
+        :param chunk_size: the maximum number of streams to retrieve in one underlying HTTP call.
+        :param max_number: the total maximum number of streams to retrieve.
+        :return: an asynchronous generator of the streams.
+        """
+        async def list_streams_one_page(skip, limit):
+            result = await self.list_user_streams_admin(uid, stream_filter, skip, limit)
+            return result.value if result else None
+
+        return offset_based_pagination(list_streams_one_page, chunk_size, max_number)
+
     @retry
     async def list_stream_members(self, stream_id: str, skip: int = 0, limit: int = 100) -> V2MembershipList:
         """List the current members of an existing stream. The stream can be of type IM, MIM, or ROOM.

symphony/bdk/core/service/user/user_service.py

@@ -1,4 +1,6 @@
 import base64
+import json
+from pathlib import Path
 from typing import Union, AsyncGenerator
 
 from symphony.bdk.core.auth.auth_session import AuthSession
@@ -21,6 +23,7 @@ from symphony.bdk.gen.pod_model.followers_list import FollowersList
 from symphony.bdk.gen.pod_model.followers_list_response import FollowersListResponse
 from symphony.bdk.gen.pod_model.following_list_response import FollowingListResponse
 from symphony.bdk.gen.pod_model.role_detail import RoleDetail
+from symphony.bdk.gen.pod_model.service_account_manifest import ServiceAccountManifest
 from symphony.bdk.gen.pod_model.string_id import StringId
 from symphony.bdk.gen.pod_model.user_filter import UserFilter
 from symphony.bdk.gen.pod_model.user_id_list import UserIdList
@@ -260,10 +263,12 @@ class UserService(OboUserService):
                  audit_trail_api: AuditTrailApi,
                  system_api: SystemApi,
                  auth_session: AuthSession,
-                 retry_config: BdkRetryConfig):
+                 retry_config: BdkRetryConfig,
+                 manifest: str):
         super().__init__(user_api, users_api, auth_session, retry_config)
         self._audit_trail_api = audit_trail_api
         self._system_api = system_api
+        self._manifest = manifest
 
     @retry
     async def get_user_detail(
@@ -898,3 +903,40 @@ class UserService(OboUserService):
         }
 
         await self._user_api.v1_admin_user_user_id_suspension_update_put(**params)
+
+    @retry
+    async def update_manifest_from_json(self, manifest_data: str) -> None:
+        """
+        Updates the user manifest from a JSON string.
+
+        :param manifest_data: A JSON string.
+        :raises json.JSONDecodeError: If the string is not valid JSON.
+        """
+        await self._user_api.v1_user_manifest_own_post(
+            session_token=await self._auth_session.session_token,
+            manifest=ServiceAccountManifest(manifest_data)
+        )
+
+    async def update_manifest_from_file(self) -> None:
+        """
+        Updates the user manifest using the file mentioned in config.yaml under 'manifest'.
+
+        :raises FileNotFoundError: If the file does not exist.
+        :raises json.JSONDecodeError: If the file content is not valid JSON.
+        :raises IOError: If the file can't be read.
+        """
+        file_path = Path(self._manifest)
+
+        with file_path.open('r', encoding='utf-8') as f:
+            content = json.load(f)
+            manifest_text = json.dumps(content)
+
+        await self._user_api.v1_user_manifest_own_post(
+            session_token=await self._auth_session.session_token,
+            manifest=ServiceAccountManifest(manifest_text)
+        )
+
+    @retry
+    async def get_manifest(self) -> ServiceAccountManifest:
+        """Retrieves own user manifest"""
+        return await self._user_api.v1_user_manifest_own_get(session_token=await self._auth_session.session_token)

symphony/bdk/core/service/version/agent_version_service.py

@@ -0,0 +1,67 @@
+import re
+from datetime import datetime, timezone
+
+from symphony.bdk.core.auth.auth_session import AuthSession
+from symphony.bdk.core.auth.jwt_helper import generate_expiration_time
+from symphony.bdk.core.config.model.bdk_retry_config import BdkRetryConfig
+from symphony.bdk.core.retry import retry
+from symphony.bdk.gen.agent_api.signals_api import SignalsApi
+from symphony.bdk.gen.exceptions import ApiException
+
+MIN_MAJOR_VERSION = 24
+MIN_MINOR_VERSION = 12
+VERSION_REGEXP = r"Agent-(\d+)\.(\d+)\..*"
+
+
+class AgentVersionService:
+    """Service class has one purpose only. It checks if version of agents supports simplified key delivery mechanism
+
+    """
+
+    def __init__(self, signals_api: SignalsApi, retry_config: BdkRetryConfig):
+        self._signals_api = signals_api
+        self._retry_config = retry_config
+        self._is_skd_supported = None
+        self._expire_at = -1
+
+    async def is_skd_supported(self) -> bool:
+        """ AgentVersionService stores cached version  flag.
+        Caching interval is the same as in to session token caching.
+        Once cache is expired it calls agent info api to update version.
+
+        :return: boolean flag if skd supported for agent
+        """
+        if (
+            self._is_skd_supported is not None
+            and self._expire_at
+            > datetime.now(timezone.utc).timestamp()
+        ):
+            return self._is_skd_supported
+        self._expire_at = generate_expiration_time()
+        self._is_skd_supported = await self._get_agent_skd_support()
+        return self._is_skd_supported
+
+
+    @retry
+    async def _get_agent_skd_support(self) -> bool:
+        try:
+            agent_info = await self._signals_api.v1_info_get()
+            if not agent_info or not agent_info.version:
+                return False
+        except ApiException:
+            return False
+        agent_major_version, agent_minor_version = self._parse_version(agent_info.version)
+        if not agent_major_version:
+            return False
+        if agent_major_version == MIN_MAJOR_VERSION:
+            return agent_minor_version >= MIN_MINOR_VERSION
+        return agent_major_version > MIN_MAJOR_VERSION
+
+    @staticmethod
+    def _parse_version(version_string):
+        if not version_string:
+            return None, None
+        match = re.match(VERSION_REGEXP, version_string)
+        if match:
+            return int(match.group(1)), int(match.group(2))
+        return None, None

symphony/bdk/core/service_factory.py

@@ -18,6 +18,7 @@ from symphony.bdk.core.service.session.session_service import SessionService
 from symphony.bdk.core.service.signal.signal_service import SignalService, OboSignalService
 from symphony.bdk.core.service.stream.stream_service import StreamService, OboStreamService
 from symphony.bdk.core.service.user.user_service import UserService, OboUserService
+from symphony.bdk.core.service.version.agent_version_service import AgentVersionService
 from symphony.bdk.gen.agent_api.attachments_api import AttachmentsApi
 from symphony.bdk.gen.agent_api.audit_trail_api import AuditTrailApi
 from symphony.bdk.gen.agent_api.datafeed_api import DatafeedApi
@@ -74,7 +75,8 @@ class ServiceFactory:
             AuditTrailApi(self._agent_client),
             PodSystemApi(self._pod_client),
             self._auth_session,
-            self._config.retry
+            self._config.retry,
+            self._config.manifest
         )
 
     def get_message_service(self) -> MessageService:
@@ -202,6 +204,14 @@ class ServiceFactory:
             self._config.retry
         )
 
+    def get_agent_version_service(self) -> AgentVersionService:
+        """Returns a fully initialized AgentVersionService
+
+        :return: a new AgentVersionService instance
+        """
+        return AgentVersionService(SignalsApi(self._agent_client),
+                                   self._config.retry)
+
 
 class OboServiceFactory:
     """Factory responsible for creating BDK service instances for OBO-enabled endpoints only:

symphony/bdk/core/symphony_bdk.py

@@ -105,7 +105,8 @@ class SymphonyBdk:
                          "You can however use services in OBO mode if app authentication is configured.")
 
     def _initialize_bot_services(self):
-        self._bot_session = AuthSession(self._authenticator_factory.get_bot_authenticator())
+        bot_authenticator = self._authenticator_factory.get_bot_authenticator()
+        self._bot_session = AuthSession(bot_authenticator)
         self._service_factory = ServiceFactory(self._api_client_factory, self._bot_session, self._config)
         self._user_service = self._service_factory.get_user_service()
         self._message_service = self._service_factory.get_message_service()
@@ -123,6 +124,7 @@ class SymphonyBdk:
         self._datafeed_loop.subscribe(self._activity_registry)
         # initialises extension service and register decorated extensions
         self._extension_service = ExtensionService(self._api_client_factory, self._bot_session, self._config)
+        bot_authenticator.agent_version_service = self._service_factory.get_agent_version_service()
 
     @bot_service
     def bot_session(self) -> AuthSession:

symphony/bdk/gen/agent_api/attachments_api.py

@@ -3,7 +3,7 @@
 
     This document refers to Symphony API calls to send and receive messages and content. They need the on-premise Agent installed to perform decryption/encryption of content.  - sessionToken and keyManagerToken can be obtained by calling the authenticationAPI on the symphony back end and the key manager respectively. Refer to the methods described in authenticatorAPI.yaml. - Actions are defined to be atomic, ie will succeed in their entirety or fail and have changed nothing. - If it returns a 40X status then it will have sent no message to any stream even if a request to some subset of the requested streams would have succeeded. - If this contract cannot be met for any reason then this is an error and the response code will be 50X. - MessageML is a markup language for messages. See reference here: https://rest-api.symphony.com/docs/messagemlv2 - **Real Time Events**: The following events are returned when reading from a real time messages and events stream (\"datafeed\"). These events will be returned for datafeeds created with the v5 endpoints. To know more about the endpoints, refer to Create Messages/Events Stream and Read Messages/Events Stream. Unless otherwise specified, all events were added in 1.46.   # noqa: E501
 
-    The version of the OpenAPI document: 22.9.1
+    The version of the OpenAPI document: 24.12.1
     Generated by: https://openapi-generator.tech
 """
 
@@ -49,13 +49,12 @@ class AttachmentsApi(object):
                 'all': [
                     'sid',
                     'session_token',
-                    'key_manager_token',
                     'file',
+                    'key_manager_token',
                 ],
                 'required': [
                     'sid',
                     'session_token',
-                    'key_manager_token',
                     'file',
                 ],
                 'nullable': [
@@ -75,22 +74,22 @@ class AttachmentsApi(object):
                         (str,),
                     'session_token':
                         (str,),
-                    'key_manager_token':
-                        (str,),
                     'file':
                         (file_type,),
+                    'key_manager_token':
+                        (str,),
                 },
                 'attribute_map': {
                     'sid': 'sid',
                     'session_token': 'sessionToken',
-                    'key_manager_token': 'keyManagerToken',
                     'file': 'file',
+                    'key_manager_token': 'keyManagerToken',
                 },
                 'location_map': {
                     'sid': 'path',
                     'session_token': 'header',
-                    'key_manager_token': 'header',
                     'file': 'form',
+                    'key_manager_token': 'header',
                 },
                 'collection_format_map': {
                 }
@@ -127,7 +126,6 @@ class AttachmentsApi(object):
                     'file_id',
                     'message_id',
                     'session_token',
-                    'key_manager_token',
                 ],
                 'nullable': [
                 ],
@@ -251,7 +249,6 @@ class AttachmentsApi(object):
         self,
         sid,
         session_token,
-        key_manager_token,
         file,
         **kwargs
     ):
@@ -261,16 +258,16 @@ class AttachmentsApi(object):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = agent_api.v1_stream_sid_attachment_create_post(sid, session_token, key_manager_token, file, async_req=True)
+        >>> thread = agent_api.v1_stream_sid_attachment_create_post(sid, session_token, file, async_req=True)
         >>> result = thread.get()
 
         Args:
             sid (str): Stream ID
             session_token (str): Session authentication token.
-            key_manager_token (str): Key Manager authentication token.
             file (file_type): The attachment body.
 
         Keyword Args:
+            key_manager_token (str): Key Manager authentication token.. [optional]
             _return_http_data_only (bool): response data without head status
                 code and headers. Default is True.
             _preload_content (bool): if False, the urllib3.HTTPResponse object
@@ -331,8 +328,6 @@ class AttachmentsApi(object):
             sid
         kwargs['session_token'] = \
             session_token
-        kwargs['key_manager_token'] = \
-            key_manager_token
         kwargs['file'] = \
             file
         return self.v1_stream_sid_attachment_create_post_endpoint.call_with_http_info(**kwargs)
@@ -343,7 +338,6 @@ class AttachmentsApi(object):
         file_id,
         message_id,
         session_token,
-        key_manager_token,
         **kwargs
     ):
         """Download an attachment.  # noqa: E501
@@ -352,7 +346,7 @@ class AttachmentsApi(object):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = agent_api.v1_stream_sid_attachment_get(sid, file_id, message_id, session_token, key_manager_token, async_req=True)
+        >>> thread = agent_api.v1_stream_sid_attachment_get(sid, file_id, message_id, session_token, async_req=True)
         >>> result = thread.get()
 
         Args:
@@ -360,9 +354,9 @@ class AttachmentsApi(object):
             file_id (str): The attachment ID (Base64-encoded)
             message_id (str): The ID of the message containing the attachment
             session_token (str): Session authentication token.
-            key_manager_token (str): Key Manager authentication token.
 
         Keyword Args:
+            key_manager_token (str): Key Manager authentication token.. [optional]
             _return_http_data_only (bool): response data without head status
                 code and headers. Default is True.
             _preload_content (bool): if False, the urllib3.HTTPResponse object
@@ -427,8 +421,6 @@ class AttachmentsApi(object):
             message_id
         kwargs['session_token'] = \
             session_token
-        kwargs['key_manager_token'] = \
-            key_manager_token
         return self.v1_stream_sid_attachment_get_endpoint.call_with_http_info(**kwargs)
 
     def v3_stream_sid_attachment_create_post(

symphony/bdk/gen/agent_api/audit_trail_api.py

@@ -3,7 +3,7 @@
 
     This document refers to Symphony API calls to send and receive messages and content. They need the on-premise Agent installed to perform decryption/encryption of content.  - sessionToken and keyManagerToken can be obtained by calling the authenticationAPI on the symphony back end and the key manager respectively. Refer to the methods described in authenticatorAPI.yaml. - Actions are defined to be atomic, ie will succeed in their entirety or fail and have changed nothing. - If it returns a 40X status then it will have sent no message to any stream even if a request to some subset of the requested streams would have succeeded. - If this contract cannot be met for any reason then this is an error and the response code will be 50X. - MessageML is a markup language for messages. See reference here: https://rest-api.symphony.com/docs/messagemlv2 - **Real Time Events**: The following events are returned when reading from a real time messages and events stream (\"datafeed\"). These events will be returned for datafeeds created with the v5 endpoints. To know more about the endpoints, refer to Create Messages/Events Stream and Read Messages/Events Stream. Unless otherwise specified, all events were added in 1.46.   # noqa: E501
 
-    The version of the OpenAPI document: 22.9.1
+    The version of the OpenAPI document: 24.12.1
     Generated by: https://openapi-generator.tech
 """
 
@@ -48,8 +48,8 @@ class AuditTrailApi(object):
             params_map={
                 'all': [
                     'session_token',
-                    'key_manager_token',
                     'start_timestamp',
+                    'key_manager_token',
                     'end_timestamp',
                     'before',
                     'after',
@@ -59,7 +59,6 @@ class AuditTrailApi(object):
                 ],
                 'required': [
                     'session_token',
-                    'key_manager_token',
                     'start_timestamp',
                 ],
                 'nullable': [
@@ -77,10 +76,10 @@ class AuditTrailApi(object):
                 'openapi_types': {
                     'session_token':
                         (str,),
-                    'key_manager_token':
-                        (str,),
                     'start_timestamp':
                         (int,),
+                    'key_manager_token':
+                        (str,),
                     'end_timestamp':
                         (int,),
                     'before':
@@ -96,8 +95,8 @@ class AuditTrailApi(object):
                 },
                 'attribute_map': {
                     'session_token': 'sessionToken',
-                    'key_manager_token': 'keyManagerToken',
                     'start_timestamp': 'startTimestamp',
+                    'key_manager_token': 'keyManagerToken',
                     'end_timestamp': 'endTimestamp',
                     'before': 'before',
                     'after': 'after',
@@ -107,8 +106,8 @@ class AuditTrailApi(object):
                 },
                 'location_map': {
                     'session_token': 'header',
-                    'key_manager_token': 'header',
                     'start_timestamp': 'query',
+                    'key_manager_token': 'header',
                     'end_timestamp': 'query',
                     'before': 'query',
                     'after': 'query',
@@ -131,7 +130,6 @@ class AuditTrailApi(object):
     def v1_audittrail_privilegeduser_get(
         self,
         session_token,
-        key_manager_token,
         start_timestamp,
         **kwargs
     ):
@@ -141,15 +139,15 @@ class AuditTrailApi(object):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = agent_api.v1_audittrail_privilegeduser_get(session_token, key_manager_token, start_timestamp, async_req=True)
+        >>> thread = agent_api.v1_audittrail_privilegeduser_get(session_token, start_timestamp, async_req=True)
         >>> result = thread.get()
 
         Args:
             session_token (str): Session authentication token.
-            key_manager_token (str): Key Manager authentication token.
             start_timestamp (int): Start timestamp in unix timestamp in millseconds.
 
         Keyword Args:
+            key_manager_token (str): Key Manager authentication token.. [optional]
             end_timestamp (int): End timestamp in unix timestamp in millseconds. If not specified, it assumes to be current time.. [optional]
             before (str): Return results from an opaque “before” cursor value as presented via a response cursor.. [optional]
             after (str): Return results from an opaque “after” cursor value as presented via a response cursor.. [optional]
@@ -214,8 +212,6 @@ class AuditTrailApi(object):
         kwargs['_host_index'] = kwargs.get('_host_index')
         kwargs['session_token'] = \
             session_token
-        kwargs['key_manager_token'] = \
-            key_manager_token
         kwargs['start_timestamp'] = \
             start_timestamp
         return self.v1_audittrail_privilegeduser_get_endpoint.call_with_http_info(**kwargs)