symphony_bdk_python 2.10.dev0__tar.gz → 2.11.0b0__tar.gz

symphony_bdk_python-2.11.0b0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.3
+Name: symphony_bdk_python
+Version: 2.11.0b0
+Summary: Symphony Bot Development Kit for Python
+License: Apache-2.0
+Author: Symphony Platform Solutions
+Author-email: symphony@finos.org
+Requires-Python: >=3.9, !=2.7.*, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*, !=3.8.*
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: PyJWT (>=2.10.0,<3.0.0)
+Requires-Dist: aiohttp (>=3.12.14,<4.0.0)
+Requires-Dist: cryptography (>=44.0.1,<45.0.0)
+Requires-Dist: defusedxml (>=0.7.1,<0.8.0)
+Requires-Dist: docutils (==0.16)
+Requires-Dist: nulltype (>=2.3.1,<3.0.0)
+Requires-Dist: python-dateutil (>=2.8.2,<3.0.0)
+Requires-Dist: pyyaml (>=6.0,<7.0)
+Requires-Dist: tenacity (>=8.0.1,<9.0.0)
+Requires-Dist: urllib3 (>=2.5.0,<3)
+Project-URL: Documentation, https://symphony-bdk-python.finos.org/
+Project-URL: Repository, https://github.com/finos/symphony-bdk-python
+Description-Content-Type: text/markdown
+
+[![FINOS - Active](https://cdn.jsdelivr.net/gh/finos/contrib-toolbox@master/images/badge-active.svg)](https://community.finos.org/docs/governance/Software-Projects/stages/active)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://www.python.org/downloads/)
+[![Pypi](https://img.shields.io/pypi/v/symphony-bdk-python)](https://pypi.org/project/symphony-bdk-python/)
+![GitHub Workflow Status (branch)](https://img.shields.io/github/workflow/status/finos/symphony-bdk-python/build/main)
+
+# Symphony BDK for Python
+
+This is the Symphony BDK for Python to help develop bots and interact with the [Symphony REST APIs](https://developers.symphony.com/restapi/reference).
+
+## Project Overview
+
+Symphony BDK for Python provides tools for building bots and integrating with Symphony APIs. This document outlines its usage, installation, and contribution guidelines.
+
+## Prerequisites
+
+- Python 3.9 or higher
+- [Poetry](https://python-poetry.org/docs/#installation)
+
+## Installation Steps
+
+### Option 1: Build from Source
+- Install dependencies: `poetry install`
+- Build the package: `poetry build`
+- Run tests: `poetry run pytest`
+- Perform a pylint scan locally: `poetry run pylint <module_name>`
+- Generate documentation locally: `cd docsrc && make html`
+
+### Verification
+Verify the successful installation by running any of the following commands:
+```
+poetry --version
+```
+
+## External Documents
+
+Refer to the following for additional guidance:
+- [Reference Documentation](https://symphony-bdk-python.finos.org/)
+- [Getting Started Guide](https://symphony-bdk-python.finos.org/markdown/getting_started.html)
+
+## Roadmap
+
+The next milestone is the [2.5.x](https://github.com/finos/symphony-bdk-python/milestone/6), focused on delivering improvements and bug fixes.
+
+## Contributing
+
+To contribute:
+1. Fork the repository.
+2. Create a feature branch: `git checkout -b feature/fooBar`
+3. Read the [Contribution Guidelines](CONTRIBUTING.md) and [Community Code of Conduct](https://www.finos.org/code-of-conduct)
+4. Commit changes: `git commit -am 'Add some fooBar'`
+5. Push changes: `git push origin feature/fooBar`
+6. Open a Pull Request.
+
+_NOTE:_ Ensure you have an active Individual Contributor License Agreement (ICLA) or Corporate Contribution License Agreement (CCLA) with FINOS.
+
+For further inquiries, email [help@finos.org](mailto:help@finos.org).
+
+
+### Updating Generated Code
+
+Python BDK uses [OpenAPITools/openapi-generator](https://github.com/OpenAPITools/openapi-generator/) to generate code. 
+To update the generated code, follow these steps:
+
+1. Checkout the latest branch of the fork (e.g., [sym-python-5.5.0](https://github.com/SymphonyPlatformSolutions/openapi-generator/tree/sym-python-5.5.0)).
+2. Update the fork source code, review, and merge it.
+3. Generate the JAR file in `openapi-generatormodules/openapi-generator-cli/target/openapi-generator-cli.jar`:
+   - Use Maven: 
+     ```bash
+     mvn clean install -Dmaven.test.skip=true && mvn clean package -Dmaven.test.skip=true
+     ```
+   - Alternatively, use IntelliJ's build button to build the project and generate the JAR file.
+4. Copy the JAR file to the Python BDK repository: `symphony-api-client-python/api_client_generation/openapi-generator-cli.jar`.
+5. Execute the generation script: 
+   ```bash
+   ./generate.sh
+   ```
+6. Commit and push the newly generated code along with the updated JAR file.
+
+
+## License
+
+Copyright 2021 Symphony LLC
+
+Distributed under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).
+
+SPDX-License-Identifier: [Apache-2.0](https://spdx.org/licenses/Apache-2.0).
+

symphony_bdk_python-2.11.0b0/pyproject.toml

@@ -0,0 +1,71 @@
+[tool.poetry]
+name = "symphony_bdk_python"
+version = "2.11.0-beta"
+license = "Apache-2.0"
+description = "Symphony Bot Development Kit for Python"
+readme = "README.md"
+authors = ["Symphony Platform Solutions <symphony@finos.org>"]
+repository = "https://github.com/finos/symphony-bdk-python"
+documentation = "https://symphony-bdk-python.finos.org/"
+packages = [
+    { include = "symphony" }
+]
+
+[tool.poetry.dependencies]
+python = ">3.9.0,<3.9.1 || >3.9.1,<4.0"
+nulltype = "^2.3.1"
+python-dateutil = "^2.8.2"
+urllib3 = ">=2.5.0,<3"
+aiohttp = "^3.12.14"
+pyyaml = "^6.0"
+PyJWT = "^2.10.0"
+cryptography = "^44.0.1"
+tenacity = "^8.0.1"
+defusedxml = "^0.7.1"
+docutils = "0.16"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.3"
+pylint = "^2.6.0"
+pytest-cov = "^5.0.0"
+pytest-asyncio = "^0.24.0"
+Sphinx = "^4.4.0"
+jinja2 = "^3.1.6"
+recommonmark = "^0.7.1"
+furo = "^2022.3.4"
+hazelcast-python-client = "^5.0.1"
+safety = "^2.3.5"
+setuptools = "^79.0.0"
+liccheck = "^0.9.2"
+coverage = {version = "^6.0b1", extras = ["toml"]}
+
+[tool.poetry.requires-plugins]
+poetry-plugin-export = ">=1.8"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+addopts = "--junitxml=test-results/junit.xml --cov --cov-report=html"
+testpaths = ["tests"]
+norecursedirs = ["*.egg", ".*", "build", "dist", "venv", "legacy"]
+junit_logging = "all"
+
+[tool.coverage.run]
+branch = true
+source = ["symphony"]
+omit = ["symphony/bdk/gen/*"]
+
+[tool.coverage.report]
+fail_under = 90.0
+
+[tool.liccheck]
+authorized_licenses = [
+    "BSD",
+    "GNU Library or Lesser General Public License (LGPL)",
+    "MIT",
+    "Apache Software",
+    "Apache-2.0",
+    "Python Software Foundation"
+]

symphony_bdk_python-2.11.0b0/symphony/bdk/core/auth/auth_session.py

@@ -0,0 +1,211 @@
+"""Module containing session handle classes.
+
+"""
+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:
+    """RSA Authentication session handle to get session and key manager tokens from.
+    It uses a BotAuthenticator to actually retrieve the tokens when needed.
+    """
+
+    def __init__(self, authenticator):
+        """
+
+        :param authenticator: the :class:`symphony.bdk.core.auth.bot_authenticator.BotAuthenticator` instance to
+          retrieve the tokens from.
+        """
+        self._session_token = None
+        self._key_manager_token = None
+        self._auth_token = None
+        self._authenticator = authenticator
+        self._expire_at = -1
+
+    async def refresh(self):
+        """Trigger re-authentication to refresh the tokens.
+        """
+        logger.debug("Authenticate")
+        self._session_token = await self._authenticator.retrieve_session_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):
+        """
+
+        :return: the session token.
+        """
+        if self._session_token is None:
+            self._session_token = await self._authenticator.retrieve_session_token()
+        return self._session_token
+
+    @property
+    async def auth_token(self):
+        """Auth token request calls the same endpoint that session token.
+        Therefore, session token is updated unintentionally,
+         since there's no explicit way to update authorization token exclusively
+         : return: (str) authorization_token like Bearer eyJh...
+        """
+
+        if (
+            self._auth_token
+            and self._expire_at
+            > datetime.now(timezone.utc).timestamp() + EXPIRATION_SAFETY_BUFFER_SECONDS
+        ):
+            return self._auth_token
+        token, expire_at = await self._authenticator.retrieve_session_token_object()
+        self._expire_at = expire_at
+        self._auth_token = token.authorization_token
+        self._session_token = token.token
+        return self._auth_token
+
+    @property
+    async def key_manager_token(self):
+        """
+
+        :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
+
+    @session_token.setter
+    def session_token(self, value):
+        """Sets the session token. Used for testing purposes only.
+
+        :param value: the new session token.
+        """
+        self._session_token = value
+
+    @key_manager_token.setter
+    def key_manager_token(self, value):
+        """Sets the key manager token. Used for testing purposes only.
+
+        :param value: the new key manager token.
+        """
+        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.
+    It uses an :class:`symphony.bdk.core.auth.obo_authenticator.OboAuthenticator` to actually retrieve the tokens when
+    needed.
+    """
+
+    def __init__(self, authenticator, user_id: int = None, username: str = None):
+        """At least user_id or username should be defined.
+
+        :param authenticator: the :class:`symphony.bdk.core.auth.obo_authenticator.OboAuthenticator` instance to
+          retrieve the tokens from.
+        :param user_id: User Id.
+        :param username: Username
+        """
+        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.")
+        if user_id is None and username is None:
+            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.
+        """
+        if self.user_id is not None:
+            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)
+
+    @property
+    async def session_token(self):
+        if self._session_token is None:
+            await self.refresh()
+        return self._session_token
+
+    @property
+    async def key_manager_token(self):
+        """
+
+        :return: an empty string since there is no key manager token in OBO mode.
+        """
+        return ""
+
+
+class AppAuthSession:
+    """Extension application RSA authentication handle to store the tokens. It uses a
+    :class:`symphony.bdk.core.auth.ext_app_authenticator.ExtensionAppAuthenticator` to actually authenticate and
+    retrieve the tokens.
+    """
+
+    def __init__(self, authenticator, app_token: str):
+        """
+
+        :param authenticator: the :class:`symphony.bdk.core.auth.ext_app_authenticator.ExtensionAppAuthenticator`
+          which will actually perform the authentication
+        :param app_token: the application token
+        """
+        self._authenticator = authenticator
+        self._app_token = app_token
+        self._expire_at = -1
+        self._symphony_token = ""
+
+    async def refresh(self) -> None:
+        """Triggers re-authentication to refresh the tokens.
+
+        :return: None
+        """
+        app_tokens = await self._authenticator.authenticate_and_retrieve_tokens(self._app_token)
+        self._symphony_token = app_tokens.symphony_token
+        self._app_token = app_tokens.app_token
+        self._expire_at = app_tokens.expire_at
+
+    @property
+    def symphony_token(self) -> str:
+        """
+
+        :return: the Symphony token
+        """
+        return self._symphony_token
+
+    @property
+    def app_token(self) -> str:
+        """
+
+        :return: the application token
+        """
+        return self._app_token
+
+    @property
+    def expire_at(self) -> int:
+        """
+
+        :return: the Unix timestamp in milliseconds of the Symphony token expiration
+        """
+        return self._expire_at

symphony_bdk_python-2.11.0b0/symphony/bdk/core/auth/bot_authenticator.py

@@ -0,0 +1,109 @@
+"""Module containing BotAuthenticator classes.
+"""
+from typing import Optional, Tuple
+from abc import ABC, abstractmethod
+
+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
+from symphony.bdk.gen.login_model.authenticate_request import AuthenticateRequest
+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):
+        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.
+
+        :return: the retrieved session token.
+        """
+        return await self._authenticate_and_get_token(self._session_auth_client)
+
+    async def retrieve_session_token_object(self) -> Tuple[Token, int]:
+        """Authenticates and retrieves a new auth token.
+
+        :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
+        )
+        return token, expire_at
+
+    async def retrieve_key_manager_token(self) -> str:
+        """Authenticated and retrieved a new key manager session.
+
+        :return: the retrieved key manager session.
+        """
+        return await self._authenticate_and_get_token(self._key_manager_auth_client)
+
+    @abstractmethod
+    async def _authenticate_and_get_token(self, api_client: ApiClient) -> str:
+        """
+
+        :param api_client: the api client instance to use to retrieve the token
+          (either self._session_auth_client or self._key_manager_auth_client)
+        :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):
+        self._bot_config = bot_config
+        super().__init__(login_api_client, relay_api_client, retry_config)
+
+    @retry(retry=authentication_retry)
+    async def _authenticate_and_get_token(self, api_client: ApiClient) -> str:
+        token_object = await self._authenticate_and_get_token_object(api_client)
+        return token_object.token
+
+    @retry(retry=authentication_retry)
+    async def _authenticate_and_get_token_object(
+        self, api_client: ApiClient, expire_at: Optional[int] = None
+    ) -> Token:
+        """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
+        )
+        req = AuthenticateRequest(token=jwt)
+        return await AuthenticationApi(api_client).pubkey_authenticate_post(req)
+
+
+class BotAuthenticatorCert(BotAuthenticator):
+    """Bot authenticator certificate implementation.
+    """
+
+    @retry(retry=authentication_retry)
+    async def _authenticate_and_get_token(self, api_client: ApiClient) -> str:
+        token = await CertificateAuthenticationApi(api_client).v1_authenticate_post()
+        return token.token

symphony_bdk_python-2.11.0b0/symphony/bdk/core/auth/jwt_helper.py

@@ -0,0 +1,95 @@
+"""Module to help with jwt handling.
+"""
+import datetime
+
+from jwt import PyJWT, DecodeError, ExpiredSignatureError
+from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
+from cryptography.x509 import load_pem_x509_certificate
+
+from symphony.bdk.core.auth.exception import AuthInitializationError
+from symphony.bdk.core.config.model.bdk_rsa_key_config import BdkRsaKeyConfig
+
+JWT_ENCRYPTION_ALGORITHM = "RS512"
+
+DEFAULT_EXPIRATION_SECONDS = (5 * 50) - 10
+
+jwt = PyJWT({"verify_sub": False})
+
+def create_signed_jwt(private_key_config: BdkRsaKeyConfig, username: str, expiration: int = None) -> str:
+    """Creates a JWT with the provided user name and expiration date, signed with the provided private key.
+
+    :param private_key_config:  The private key configuration for a service account or an extension app.
+    :param username:            The username of the user to authenticate.
+    :param expiration:          Expiration of the authentication request in seconds.
+                                By default the signed jwt will be valid in maximum 290 seconds (4min 50s)
+                                which is the maximum expiration accepted by the Symphony backend.
+
+    :return: a signed JWT for a specific user or an extension app.
+    """
+    expiration = expiration if expiration is not None else int(
+        datetime.datetime.now(datetime.timezone.utc).timestamp() + DEFAULT_EXPIRATION_SECONDS)
+    payload = {
+        "sub": username,
+        "exp": expiration
+    }
+    return create_signed_jwt_with_claims(private_key_config.get_private_key_content(), payload)
+
+
+def create_signed_jwt_with_claims(private_key: str, payload: dict) -> str:
+    """Creates a JWT with the payload signed with the provided private key content.
+    For testing purposes only.
+
+    :param private_key: the privste key content in string format.
+    :param payload: the payload (aka claims) of the JWT in dict format.
+    :return: a signed JWT
+    """
+    return jwt.encode(payload, private_key, algorithm=JWT_ENCRYPTION_ALGORITHM)
+
+
+def validate_jwt(jwt_token: str, certificate: str, allowed_audience: str) -> dict:
+    """Validate a jwt against a X509 certificate in pem format and returns the jwt claims.
+
+    :param jwt_token: the token to be validated
+    :param certificate: the X509 certificate in pem format to be used for jwt validation
+    :param allowed_audience: the expected value in "aud" claim. If it doesn't match jwt will be rejected
+    :return: a dictionary containing the jwt claims
+    :raise AuthInitializationError: If the certificate or jwt are invalid.
+    """
+    try:
+        return jwt.decode(jwt_token, _parse_public_key_from_x509_cert(certificate),
+                          algorithms=[JWT_ENCRYPTION_ALGORITHM], audience=allowed_audience)
+    except (DecodeError, ExpiredSignatureError) as exc:
+        raise AuthInitializationError("Unable to validate the jwt") from exc
+
+
+def generate_expiration_time() -> int:
+    """Generates integer timestamp value for jwt token
+    :return: timestamp value
+    """
+    return int(
+        datetime.datetime.now(datetime.timezone.utc).timestamp()
+        + DEFAULT_EXPIRATION_SECONDS
+    )
+
+
+def _parse_public_key_from_x509_cert(certificate: str) -> str:
+    """Returns the public key in PEM format given a X509 certificate content in PEM format
+
+    :param certificate: the X509 certificate in PEM format
+    :return: the public key associated to the certificate in PEM format
+    """
+    try:
+        public_key = load_pem_x509_certificate(certificate.encode()).public_key()
+        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_python-2.11.0b0/symphony/bdk/core/config/model/bdk_config.py

@@ -0,0 +1,47 @@
+from symphony.bdk.core.config.model.bdk_app_config import BdkAppConfig
+from symphony.bdk.core.config.model.bdk_bot_config import BdkBotConfig
+from symphony.bdk.core.config.model.bdk_client_config import BdkClientConfig
+from symphony.bdk.core.config.model.bdk_retry_config import BdkRetryConfig
+from symphony.bdk.core.config.model.bdk_server_config import BdkServerConfig
+from symphony.bdk.core.config.model.bdk_ssl_config import BdkSslConfig
+from symphony.bdk.core.config.model.bdk_datafeed_config import BdkDatafeedConfig
+from symphony.bdk.core.config.model.bdk_datahose_config import BdkDatahoseConfig
+
+
+class BdkConfig(BdkServerConfig):
+    """Class containing the whole BDK configuration.
+    """
+
+    def __init__(self, **config):
+        """
+
+        :param config: the dict containing the server configuration parameters.
+        """
+        super().__init__(scheme=config.get("scheme"), host=config.get("host"), port=config.get("port"),
+                         context=config.get("context"), proxy=config.get("proxy"),
+                         default_headers=config.get("defaultHeaders"))
+        self.agent = BdkClientConfig(self, config.get("agent"))
+        self.pod = BdkClientConfig(self, config.get("pod"))
+        self.key_manager = BdkClientConfig(self, config.get("keyManager"))
+        self.session_auth = BdkClientConfig(self, config.get("sessionAuth"))
+        self.bot = BdkBotConfig(config.get("bot"))
+        self.ssl = BdkSslConfig(config.get("ssl"))
+        self.app = BdkAppConfig(config.get("app"))
+        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:
+        """
+
+        :return: true if bot service account is specified in the configuration.
+        """
+        return self.bot.username is not None
+
+    def is_app_configured(self) -> bool:
+        """
+
+        :return: true if app id is specified in the configuration.
+        """
+        return self.app.app_id is not None