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

symphony/bdk/core/__init__.py

@@ -4,6 +4,7 @@ There is an outstanding issue with aiohttp and Python 3.8+ on Windows. This affe
 proxy on Windows with Python 3.8+. As known workaround, the following code is meant to avoid this issue by detecting the
 operating system and setting WindowsSelectorEventLoopPolicy as event loop policy.
 """
+
 import asyncio
 import os
 

symphony/bdk/core/activity/__init__.py

@@ -1,2 +1 @@
-"""Package containing all modules related to the Activity API
-"""
+"""Package containing all modules related to the Activity API"""

symphony/bdk/core/activity/api.py

@@ -1,10 +1,10 @@
 from abc import ABC, abstractmethod
-from typing import TypeVar, Generic
+from typing import Generic, TypeVar
 
 from symphony.bdk.gen.agent_model.v4_initiator import V4Initiator
 
-C = TypeVar('C')  # Context type
-E = TypeVar('E')  # Event type
+C = TypeVar("C")  # Context type
+E = TypeVar("E")  # Event type
 
 
 class ActivityContext(Generic[E]):
@@ -60,7 +60,7 @@ class AbstractActivity(ABC, Generic[C]):
         """
 
     def before_matcher(self, context: C):
-        """ This callback can be used to prepare :py:class:`ActivityContext` before actually processing the `matches`
+        """This callback can be used to prepare :py:class:`ActivityContext` before actually processing the `matches`
         method.
 
         :param context: an instance of :py:class:`ActivityContext`

symphony/bdk/core/activity/command.py

@@ -14,11 +14,15 @@ logger = logging.getLogger(__name__)
 
 
 class CommandContext(ActivityContext[V4MessageSent]):
-    """Default implementation of the :py:class:`ActivityContext` handled by the :py:class:`CommandActivity`.
-    """
-
-    def __init__(self, initiator: V4Initiator, source_event: V4MessageSent, bot_display_name: str,
-                 bot_user_id: int = None):
+    """Default implementation of the :py:class:`ActivityContext` handled by the :py:class:`CommandActivity`."""
+
+    def __init__(
+        self,
+        initiator: V4Initiator,
+        source_event: V4MessageSent,
+        bot_display_name: str,
+        bot_user_id: int = None,
+    ):
         self._message_id = source_event.message.message_id
         self._stream_id = source_event.message.stream.stream_id
         self._bot_display_name = bot_display_name
@@ -56,8 +60,7 @@ class CommandContext(ActivityContext[V4MessageSent]):
 
 
 class CommandActivity(AbstractActivity[CommandContext]):
-    """A command activity corresponds to any message sent in a chat where the bot is part of.
-    """
+    """A command activity corresponds to any message sent in a chat where the bot is part of."""
 
     def __init__(self):
         self._bot_user_id = None
@@ -103,15 +106,20 @@ class SlashCommandActivity(CommandActivity):
 
         if self._requires_mention_bot:
             # The user id will be loaded in runtime in a lazy way
-            self._command_pattern.prepend_token(MatchingUserIdMentionToken(lambda: self.bot_user_id))
+            self._command_pattern.prepend_token(
+                MatchingUserIdMentionToken(lambda: self.bot_user_id)
+            )
 
     @property
     def name(self) -> str:
         return self._name
 
     def build_command_description(self) -> str:
-        return self._description + " (mention required)" if self._requires_mention_bot \
+        return (
+            self._description + " (mention required)"
+            if self._requires_mention_bot
             else self._description + " (mention not required)"
+        )
 
     def matches(self, context: CommandContext) -> bool:
         match_result = self._command_pattern.get_match_result(context.source_event.message)

symphony/bdk/core/activity/exception.py

@@ -1,7 +1,5 @@
-"""Module containing all activities related exception.
-"""
+"""Module containing all activities related exception."""
 
 
 class FatalActivityExecutionException(Exception):
-    """A Fatal error occurred during an activity execution flow
-    """
+    """A Fatal error occurred during an activity execution flow"""

symphony/bdk/core/activity/help_command.py

@@ -18,5 +18,6 @@ class HelpCommand(SlashCommandActivity):
         help_message = ""
         for act in activity_list:
             help_message += "<li>" + act.name + " - " + act.build_command_description() + "</li>"
-        await self._bdk.messages().send_message(context.stream_id,
-                                                "<messageML><ul>" + help_message + "</ul></messageML>")
+        await self._bdk.messages().send_message(
+            context.stream_id, "<messageML><ul>" + help_message + "</ul></messageML>"
+        )

symphony/bdk/core/activity/parsing/arguments.py

@@ -1,4 +1,4 @@
-from symphony.bdk.core.activity.parsing.message_entities import Mention, Hashtag, Cashtag
+from symphony.bdk.core.activity.parsing.message_entities import Cashtag, Hashtag, Mention
 
 
 class Arguments:

symphony/bdk/core/activity/parsing/command_token.py

@@ -1,5 +1,4 @@
-"""This module gathers all token classes that we can use for {@link SlashCommandPattern}
-"""
+"""This module gathers all token classes that we can use for {@link SlashCommandPattern}"""
 
 import re
 from abc import ABC, abstractmethod
@@ -151,5 +150,7 @@ class MatchingUserIdMentionToken(AbstractCommandToken):
         return isinstance(token, Mention) and token.user_id == self._matching_user_id_supplier()
 
     def __eq__(self, o: object) -> bool:
-        return isinstance(o, MatchingUserIdMentionToken) and \
-               self._matching_user_id_supplier() == o._matching_user_id_supplier()
+        return (
+            isinstance(o, MatchingUserIdMentionToken)
+            and self._matching_user_id_supplier() == o._matching_user_id_supplier()
+        )

symphony/bdk/core/activity/parsing/input_tokenizer.py

@@ -23,7 +23,7 @@ class InputTokenizer:
         :param message: message to be tokenized.
         """
         self._document = fromstring(message.message)
-        json_data = message.data if hasattr(message, 'data') and message.data else "{}"
+        json_data = message.data if hasattr(message, "data") and message.data else "{}"
         self._data_node = json.loads(json_data)
         self._buffer = ""
         self._tokens = []
@@ -43,7 +43,7 @@ class InputTokenizer:
         if self._is_entity_node(root):
             self._parse_buffer()
             entity_id = root.attrib[InputTokenizer.data_entity_id]
-            entity_type = self._data_node[entity_id]['type']
+            entity_type = self._data_node[entity_id]["type"]
             if self._is_entity_type_supported(entity_type):
                 self._parse_entity_node(entity_id, root)
             else:
@@ -91,14 +91,22 @@ class InputTokenizer:
         :param root: root of the xml document
         :return: Whether the node is a known entity.
         """
-        if root.tag == "span" and "class" in root.attrib and root.attrib["class"] == "entity" \
-                and InputTokenizer.data_entity_id in root.attrib:
+        if (
+            root.tag == "span"
+            and "class" in root.attrib
+            and root.attrib["class"] == "entity"
+            and InputTokenizer.data_entity_id in root.attrib
+        ):
             return root.attrib[InputTokenizer.data_entity_id] in self._data_node
         return False
 
     @staticmethod
     def _is_entity_type_supported(entity_type):
-        return entity_type in ["org.symphonyoss.taxonomy", "org.symphonyoss.fin.security", "com.symphony.user.mention"]
+        return entity_type in [
+            "org.symphonyoss.taxonomy",
+            "org.symphonyoss.fin.security",
+            "com.symphony.user.mention",
+        ]
 
     @property
     def tokens(self):

symphony/bdk/core/activity/parsing/match_result.py

@@ -24,6 +24,8 @@ class MatchResult:
         return self._arguments
 
     def __eq__(self, other):
-        return isinstance(other, MatchResult) \
-               and self._is_matching == other._is_matching \
-               and self._arguments == other._arguments
+        return (
+            isinstance(other, MatchResult)
+            and self._is_matching == other._is_matching
+            and self._arguments == other._arguments
+        )

symphony/bdk/core/activity/parsing/message_entities.py

@@ -1,5 +1,4 @@
-"""This module gathers all entities that we can find in a message.
-"""
+"""This module gathers all entities that we can find in a message."""
 
 
 class Cashtag:
@@ -67,7 +66,9 @@ class Mention:
         return self._user_id
 
     def __eq__(self, o: object) -> bool:
-        return isinstance(o, Mention) \
-               and self._text == o._text \
-               and self._user_display_name == o._user_display_name \
-               and self._user_id == o._user_id
+        return (
+            isinstance(o, Mention)
+            and self._text == o._text
+            and self._user_display_name == o._user_display_name
+            and self._user_id == o._user_id
+        )

symphony/bdk/core/activity/parsing/slash_command_pattern.py

@@ -1,7 +1,13 @@
 import re
 
-from symphony.bdk.core.activity.parsing.command_token import StaticCommandToken, StringArgumentCommandToken, \
-    HashArgumentCommandToken, CashArgumentCommandToken, MentionArgumentCommandToken, ArgumentCommandToken
+from symphony.bdk.core.activity.parsing.command_token import (
+    ArgumentCommandToken,
+    CashArgumentCommandToken,
+    HashArgumentCommandToken,
+    MentionArgumentCommandToken,
+    StaticCommandToken,
+    StringArgumentCommandToken,
+)
 from symphony.bdk.core.activity.parsing.input_tokenizer import InputTokenizer
 from symphony.bdk.core.activity.parsing.match_result import MatchResult
 from symphony.bdk.gen.agent_model.v4_message import V4Message
@@ -23,10 +29,15 @@ class SlashCommandPattern:
     whitespace_pattern = re.compile(r"\s+")
 
     def __init__(self, pattern: str):
-        self._tokens = [self.create_token(pattern) for pattern in
-                        re.split(SlashCommandPattern.whitespace_pattern, pattern) if pattern]
-
-        filtered_tokens_arg_names = list(filter(lambda a: a is not None, map(self.get_arg_name, self._tokens)))
+        self._tokens = [
+            self.create_token(pattern)
+            for pattern in re.split(SlashCommandPattern.whitespace_pattern, pattern)
+            if pattern
+        ]
+
+        filtered_tokens_arg_names = list(
+            filter(lambda a: a is not None, map(self.get_arg_name, self._tokens))
+        )
         if not len(set(filtered_tokens_arg_names)) == len(filtered_tokens_arg_names):
             raise ValueError("Argument names must be unique")
 
@@ -67,7 +78,11 @@ class SlashCommandPattern:
         """
         input_tokenizer = InputTokenizer(message)
         input_tokens = input_tokenizer.tokens
-        return MatchResult(True, self.get_arguments(input_tokens)) if self.matches(input_tokens) else MatchResult(False)
+        return (
+            MatchResult(True, self.get_arguments(input_tokens))
+            if self.matches(input_tokens)
+            else MatchResult(False)
+        )
 
     def matches(self, input_tokens):
         """

symphony/bdk/core/activity/registry.py

@@ -1,16 +1,18 @@
 import logging
 
-from symphony.bdk.gen.agent_model.v4_user_joined_room import V4UserJoinedRoom
-
 from symphony.bdk.core.activity.api import AbstractActivity
 from symphony.bdk.core.activity.command import CommandActivity, CommandContext, SlashCommandActivity
-from symphony.bdk.core.activity.form import FormReplyContext, FormReplyActivity
-from symphony.bdk.core.activity.user_joined_room import UserJoinedRoomContext, UserJoinedRoomActivity
+from symphony.bdk.core.activity.form import FormReplyActivity, FormReplyContext
+from symphony.bdk.core.activity.user_joined_room import (
+    UserJoinedRoomActivity,
+    UserJoinedRoomContext,
+)
 from symphony.bdk.core.service.datafeed.real_time_event_listener import RealTimeEventListener
 from symphony.bdk.core.service.session.session_service import SessionService
 from symphony.bdk.gen.agent_model.v4_initiator import V4Initiator
 from symphony.bdk.gen.agent_model.v4_message_sent import V4MessageSent
 from symphony.bdk.gen.agent_model.v4_symphony_elements_action import V4SymphonyElementsAction
+from symphony.bdk.gen.agent_model.v4_user_joined_room import V4UserJoinedRoom
 
 logger = logging.getLogger(__name__)
 
@@ -22,6 +24,7 @@ def _initialize_display_name(func):
     :param func: the function to be decorated
     :return: the decorated function
     """
+
     async def decorator(*args, **kwargs):
         registry = args[0]
         await registry.fetch_bot_info()
@@ -59,7 +62,9 @@ class ActivityRegistry(RealTimeEventListener):
         for act in self._activity_list:
             if act == activity:
                 self._activity_list.remove(act)
-                logger.debug("Activity '%s' has been removed/unsubscribed in order to be replaced", act)
+                logger.debug(
+                    "Activity '%s' has been removed/unsubscribed in order to be replaced", act
+                )
 
     def slash(self, command: str, mention_bot: bool = True, description: str = ""):
         """Decorator around a listener callback coroutine which takes a
@@ -72,8 +77,11 @@ class ActivityRegistry(RealTimeEventListener):
         :param description: command description
         :return: None
         """
+
         def decorator(func):
-            logger.debug("Registering slash command with command=%s, mention_bot=%s", command, mention_bot)
+            logger.debug(
+                "Registering slash command with command=%s, mention_bot=%s", command, mention_bot
+            )
             self.register(SlashCommandActivity(command, mention_bot, func, description))
             return func
 
@@ -89,7 +97,9 @@ class ActivityRegistry(RealTimeEventListener):
                     await act.on_activity(context)
 
     @_initialize_display_name
-    async def on_symphony_elements_action(self, initiator: V4Initiator, event: V4SymphonyElementsAction):
+    async def on_symphony_elements_action(
+        self, initiator: V4Initiator, event: V4SymphonyElementsAction
+    ):
         context = FormReplyContext(initiator, event)
         for act in self._activity_list:
             if isinstance(act, FormReplyActivity):

symphony/bdk/core/auth/__init__.py

@@ -1,2 +1 @@
-"""Package containing all modules related to authentication
-"""
+"""Package containing all modules related to authentication"""

symphony/bdk/core/auth/auth_session.py

@@ -1,14 +1,15 @@
-"""Module containing session handle classes.
+"""Module containing session handle classes."""
 
-"""
-from datetime import datetime, timezone
 import logging
+from datetime import datetime, timezone
 
 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:
@@ -29,11 +30,13 @@ class AuthSession:
         self._expire_at = -1
 
     async def refresh(self):
-        """Trigger re-authentication to refresh the tokens.
-        """
+        """Trigger re-authentication to refresh the tokens."""
         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 +74,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 +98,13 @@ 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.
@@ -108,21 +122,26 @@ class OboAuthSession(AuthSession):
         """
         super().__init__(authenticator)
         if user_id is not None and username is not None:
-            raise AuthInitializationError("Username and user id for OBO authentication should not be defined at "
-                                          "a same time.")
+            raise AuthInitializationError(
+                "Username and user id for OBO authentication should not be defined at a same time."
+            )
         if user_id is None and username is None:
-            raise AuthInitializationError("At least username or user id should be defined for "
-                                          "OBO authentication.")
+            raise AuthInitializationError(
+                "At least username or user id should be defined for OBO authentication."
+            )
         self.user_id = user_id
         self.username = username
 
     async def refresh(self):
-        """Trigger re-authentication to refresh the OBO session token.
-        """
+        """Trigger re-authentication to refresh the OBO session token."""
         if self.user_id is not None:
-            self._session_token = await self._authenticator.retrieve_obo_session_token_by_user_id(self.user_id)
+            self._session_token = await self._authenticator.retrieve_obo_session_token_by_user_id(
+                self.user_id
+            )
         if self.username is not None:
-            self._session_token = await self._authenticator.retrieve_obo_session_token_by_username(self.username)
+            self._session_token = await self._authenticator.retrieve_obo_session_token_by_username(
+                self.username
+            )
 
     @property
     async def session_token(self):

symphony/bdk/core/auth/authenticator_factory.py

@@ -1,11 +1,21 @@
-"""Module for instantiating various authenticator objects.
-"""
+"""Module for instantiating various authenticator objects."""
 
-from symphony.bdk.core.auth.bot_authenticator import BotAuthenticator, BotAuthenticatorRsa, BotAuthenticatorCert
+from symphony.bdk.core.auth.bot_authenticator import (
+    BotAuthenticator,
+    BotAuthenticatorCert,
+    BotAuthenticatorRsa,
+)
 from symphony.bdk.core.auth.exception import AuthInitializationError
-from symphony.bdk.core.auth.ext_app_authenticator import ExtensionAppAuthenticator, ExtensionAppAuthenticatorRsa, \
-    ExtensionAppAuthenticatorCert
-from symphony.bdk.core.auth.obo_authenticator import OboAuthenticator, OboAuthenticatorRsa, OboAuthenticatorCert
+from symphony.bdk.core.auth.ext_app_authenticator import (
+    ExtensionAppAuthenticator,
+    ExtensionAppAuthenticatorCert,
+    ExtensionAppAuthenticatorRsa,
+)
+from symphony.bdk.core.auth.obo_authenticator import (
+    OboAuthenticator,
+    OboAuthenticatorCert,
+    OboAuthenticatorRsa,
+)
 from symphony.bdk.core.client.api_client_factory import ApiClientFactory
 from symphony.bdk.core.config.model.bdk_config import BdkConfig
 from symphony.bdk.gen.auth_api.certificate_authentication_api import CertificateAuthenticationApi
@@ -45,18 +55,20 @@ class AuthenticatorFactory:
                 self._config.bot,
                 self._api_client_factory.get_login_client(),
                 self._api_client_factory.get_relay_client(),
-                self._config.retry
+                self._config.retry,
             )
         if self._config.bot.is_certificate_configuration_valid():
             return BotAuthenticatorCert(
                 self._api_client_factory.get_session_auth_client(),
                 self._api_client_factory.get_key_auth_client(),
-                self._config.retry
+                self._config.retry,
             )
-        raise AuthInitializationError("RSA or certificate authentication should be configured. "
-                                      "Only one field among private key path or content should be configured "
-                                      "for bot RSA authentication. "
-                                      "The path field should be specified for bot certificate authentication.")
+        raise AuthInitializationError(
+            "RSA or certificate authentication should be configured. "
+            "Only one field among private key path or content should be configured "
+            "for bot RSA authentication. "
+            "The path field should be specified for bot certificate authentication."
+        )
 
     def get_obo_authenticator(self) -> OboAuthenticator:
         """Creates a new instance of a Obo Authenticator service.
@@ -68,13 +80,17 @@ class AuthenticatorFactory:
             return OboAuthenticatorRsa(
                 app_config,
                 AuthenticationApi(self._api_client_factory.get_login_client()),
-                self._config.retry
+                self._config.retry,
             )
         if app_config.is_certificate_configuration_valid():
-            authentication_api = CertificateAuthenticationApi(self._api_client_factory.get_app_session_auth_client())
+            authentication_api = CertificateAuthenticationApi(
+                self._api_client_factory.get_app_session_auth_client()
+            )
             return OboAuthenticatorCert(authentication_api, self._config.retry)
-        raise AuthInitializationError("Application under 'app' field should be configured with a private key or "
-                                      "a certificate in order to use OBO authentication.")
+        raise AuthInitializationError(
+            "Application under 'app' field should be configured with a private key or "
+            "a certificate in order to use OBO authentication."
+        )
 
     def get_extension_app_authenticator(self) -> ExtensionAppAuthenticator:
         """Creates a new instance of an extension app authenticator service.
@@ -88,14 +104,18 @@ class AuthenticatorFactory:
                 PodApi(self._api_client_factory.get_pod_client()),
                 app_config.app_id,
                 app_config.private_key,
-                self._config.retry
+                self._config.retry,
             )
         if app_config.is_certificate_configuration_valid():
             return ExtensionAppAuthenticatorCert(
-                CertificateAuthenticationApi(self._api_client_factory.get_app_session_auth_client()),
+                CertificateAuthenticationApi(
+                    self._api_client_factory.get_app_session_auth_client()
+                ),
                 CertificatePodApi(self._api_client_factory.get_app_session_auth_client()),
                 app_config.app_id,
-                self._config.retry
+                self._config.retry,
             )
-        raise AuthInitializationError("Application under 'app' field should be configured with a private key path or "
-                                      "content in order to authenticate extension app.")
+        raise AuthInitializationError(
+            "Application under 'app' field should be configured with a private key path or "
+            "content in order to authenticate extension app."
+        )

symphony/bdk/core/auth/bot_authenticator.py

@@ -1,13 +1,14 @@
-"""Module containing BotAuthenticator classes.
-"""
-from typing import Optional, Tuple
+"""Module containing BotAuthenticator classes."""
+
 from abc import ABC, abstractmethod
+from typing import Optional, Tuple
 
 from symphony.bdk.core.auth.jwt_helper import create_signed_jwt, generate_expiration_time
 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
@@ -16,14 +17,18 @@ from symphony.bdk.gen.login_model.token import Token
 
 
 class BotAuthenticator(ABC):
-    """Bot authentication service.
-    """
-
-    def __init__(self, session_auth_client: ApiClient, key_manager_auth_client: ApiClient,
-                 retry_config: BdkRetryConfig):
+    """Bot authentication service."""
+
+    def __init__(
+        self,
+        session_auth_client: ApiClient,
+        key_manager_auth_client: ApiClient,
+        retry_config: BdkRetryConfig,
+    ):
         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.
@@ -38,9 +43,7 @@ class BotAuthenticator(ABC):
         :return: retrieved token object + expiration date.
         """
         expire_at = generate_expiration_time()
-        token = await self._authenticate_and_get_token_object(
-            self._session_auth_client, expire_at
-        )
+        token = await self._authenticate_and_get_token_object(self._session_auth_client, expire_at)
         return token, expire_at
 
     async def retrieve_key_manager_token(self) -> str:
@@ -59,13 +62,25 @@ 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.
-    """
 
-    def __init__(self, bot_config: BdkBotConfig, login_api_client: ApiClient, relay_api_client: ApiClient,
-                 retry_config: BdkRetryConfig):
+class BotAuthenticatorRsa(BotAuthenticator):
+    """Bot authenticator RSA implementation."""
+
+    def __init__(
+        self,
+        bot_config: BdkBotConfig,
+        login_api_client: ApiClient,
+        relay_api_client: ApiClient,
+        retry_config: BdkRetryConfig,
+    ):
         self._bot_config = bot_config
         super().__init__(login_api_client, relay_api_client, retry_config)
 
@@ -81,16 +96,13 @@ class BotAuthenticatorRsa(BotAuthenticator):
         """Calls pubkey auth endpoint with signed jwt token.
         :return: token object which might contain a few tokens inside
         """
-        jwt = create_signed_jwt(
-            self._bot_config.private_key, self._bot_config.username, expire_at
-        )
+        jwt = create_signed_jwt(self._bot_config.private_key, self._bot_config.username, expire_at)
         req = AuthenticateRequest(token=jwt)
         return await AuthenticationApi(api_client).pubkey_authenticate_post(req)
 
 
 class BotAuthenticatorCert(BotAuthenticator):
-    """Bot authenticator certificate implementation.
-    """
+    """Bot authenticator certificate implementation."""
 
     @retry(retry=authentication_retry)
     async def _authenticate_and_get_token(self, api_client: ApiClient) -> str:

symphony/bdk/core/auth/exception.py

@@ -1,10 +1,8 @@
-"""Module containing all authentication related exception.
-"""
+"""Module containing all authentication related exception."""
 
 
 class AuthInitializationError(Exception):
-    """Thrown when unable to read/parse a RSA Private Key or a certificate.
-    """
+    """Thrown when unable to read/parse a RSA Private Key or a certificate."""
 
     def __init__(self, message: str):
         super().__init__()
@@ -12,8 +10,7 @@ class AuthInitializationError(Exception):
 
 
 class AuthUnauthorizedError(Exception):
-    """When thrown, it means that authentication cannot be performed for several reasons
-    """
+    """When thrown, it means that authentication cannot be performed for several reasons"""
 
     def __init__(self, message: str, cause: Exception = None):
         super().__init__()