lusid-sdk 1.1.131__py3-none-any.whl → 2.1.683__py3-none-any.whl

lusid/tcp/tcp_keep_alive_probes.py

@@ -1,110 +0,0 @@
-from urllib3 import HTTPSConnectionPool, HTTPConnectionPool, PoolManager, ProxyManager
-import socket
-import sys
-
-# The content to send on Mac OS in the TCP Keep Alive probe
-TCP_KEEPALIVE = 0x10
-# The maximum time to keep the connection idle before sending probes
-TCP_KEEP_IDLE = 60
-# The interval between probes
-TCP_KEEPALIVE_INTERVAL = 60
-# The maximum number of failed probes before terminating the connection
-TCP_KEEP_CNT = 3
-
-
-class TCPKeepAliveValidationMethods:
-    """
-    This class contains a single method whose sole purpose is to set up TCP Keep Alive probes on the socket for a
-    connection. This is necessary for long running requests which will be silently terminated by the AWS Network Load
-    Balancer which kills a connection if it is idle for more then 350 seconds.
-    """
-    @staticmethod
-    def adjust_connection_socket(conn, protocol: str = "https"):
-        """
-        Adjusts the socket settings so that the client sends a TCP keep alive probe over the connection. This is only
-        applied where possible, if the ability to set the socket options is not available, for example using Anaconda,
-        then the settings will be left as is.
-
-        :param conn: The connection to update the socket settings for
-        :param str protocol: The protocol of the connection
-
-        :return: None
-        """
-
-        if protocol == "http":
-            # It isn't clear how to set this up over HTTP, it seems to differ from HTTPs
-            return
-
-        # TCP Keep Alive Probes for different platforms
-        platform = sys.platform
-        # TCP Keep Alive Probes for Linux
-        if (platform == 'linux' and hasattr(conn.sock, "setsockopt") and hasattr(socket, "SO_KEEPALIVE") and
-                hasattr(socket, "TCP_KEEPIDLE") and hasattr(socket, "TCP_KEEPINTVL") and hasattr(socket, "TCP_KEEPCNT")):
-            conn.sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-            conn.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, TCP_KEEP_IDLE)
-            conn.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, TCP_KEEPALIVE_INTERVAL)
-            conn.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, TCP_KEEP_CNT)
-
-        # TCP Keep Alive Probes for Windows OS
-        elif platform == 'win32' and hasattr(socket, "SIO_KEEPALIVE_VALS") and getattr(conn.sock, "ioctl", None) is not None:
-            conn.sock.ioctl(socket.SIO_KEEPALIVE_VALS, (1, TCP_KEEP_IDLE * 1000, TCP_KEEPALIVE_INTERVAL * 1000))
-
-        # TCP Keep Alive Probes for Mac OS
-        elif platform == 'darwin' and getattr(conn.sock, "setsockopt", None) is not None:
-            conn.sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-            conn.sock.setsockopt(socket.IPPROTO_TCP, TCP_KEEPALIVE, TCP_KEEPALIVE_INTERVAL)
-
-
-class TCPKeepAliveHTTPSConnectionPool(HTTPSConnectionPool):
-    """
-    This class overrides the _validate_conn method in the HTTPSConnectionPool class. This is the entry point to use
-    for modifying the socket as it is called after the socket is created and before the request is made.
-    """
-    def _validate_conn(self, conn):
-        """
-        Called right before a request is made, after the socket is created.
-        """
-        # Call the method on the base class
-        super()._validate_conn(conn)
-
-        # Set up TCP Keep Alive probes, this is the only line added to this function
-        TCPKeepAliveValidationMethods.adjust_connection_socket(conn, "https")
-
-
-class TCPKeepAliveHTTPConnectionPool(HTTPConnectionPool):
-    """
-    This class overrides the _validate_conn method in the HTTPSConnectionPool class. This is the entry point to use
-    for modifying the socket as it is called after the socket is created and before the request is made.
-
-    In the base class this method is passed completely.
-    """
-
-    def _validate_conn(self, conn):
-        """
-        Called right before a request is made, after the socket is created.
-        """
-        # Call the method on the base class
-        super()._validate_conn(conn)
-
-        # Set up TCP Keep Alive probes, this is the only line added to this function
-        TCPKeepAliveValidationMethods.adjust_connection_socket(conn, "http")
-
-
-class TCPKeepAlivePoolManager(PoolManager):
-    """
-    This Pool Manager has only had the pool_classes_by_scheme variable changed. This now points at the TCPKeepAlive
-    connection pools rather than the default connection pools.
-    """
-    def __init__(self, num_pools=10, headers=None, **connection_pool_kw):
-        super().__init__(num_pools=num_pools, headers=headers, **connection_pool_kw)
-        self.pool_classes_by_scheme = {"http": TCPKeepAliveHTTPConnectionPool, "https": TCPKeepAliveHTTPSConnectionPool}
-
-
-class TCPKeepAliveProxyManager(ProxyManager):
-    """
-    This Proxy Manager has only had the pool_classes_by_scheme variable changed. This now points at the TCPKeepAlive
-    connection pools rather than the default connection pools.
-    """
-    def __init__(self, proxy_url, num_pools=10, headers=None, proxy_headers=None, **connection_pool_kw):
-        super().__init__(proxy_url=proxy_url, num_pools=num_pools, headers=headers, proxy_headers=proxy_headers, **connection_pool_kw)
-        self.pool_classes_by_scheme = {"http": TCPKeepAliveHTTPConnectionPool, "https": TCPKeepAliveHTTPSConnectionPool}

lusid/utilities/__init__.py

@@ -1,8 +0,0 @@
-from lusid.utilities.api_client_builder import ApiClientBuilder
-from lusid.utilities.api_configuration_loader import ApiConfigurationLoader
-from lusid.utilities.refreshing_token import RefreshingToken
-from lusid.utilities.api_client_factory import ApiClientFactory
-from lusid.utilities.lusid_retry import lusidretry
-from lusid.utilities.proxy_config import ProxyConfig
-from lusid.utilities.api_configuration import ApiConfiguration
-from lusid.utilities.config_keys import ConfigKeys

lusid/utilities/api_client_builder.py

@@ -1,145 +0,0 @@
-import os
-
-from urllib3 import make_headers
-
-from lusid import Configuration, ApiClient
-from .api_configuration_loader import ApiConfigurationLoader
-from .refreshing_token import RefreshingToken
-
-
-class ApiClientBuilder:
-    """
-    The ApiClientBuilder is responsible for building a lusid.ApiClient. This includes obtaining an access token from
-    Okta or using the provided token.
-
-    Any validation on the inputs required to build a lusid.ApiClient is the responsibility of this ApiClientBuilder.
-    """
-
-    @staticmethod
-    def __check_required_fields(object_to_check, fields):
-        """
-        This function checks that the provided fields on an object are populated with values other than None
-
-        :param object_to_check: The object to check the fields (a.k.a attributes) of
-        :param list[str] fields: The fields to check on the object
-
-        :return: None
-        """
-        # Check for fields which have a value of None
-        missing_fields = [field for field in fields if getattr(object_to_check, field) is None]
-
-        # Raise an error if any fields have a value of None
-        if len(missing_fields) > 0:
-            raise ValueError(
-                f"The fields {str(missing_fields)} on the {object_to_check.__class__.__name__} are set to None, "
-                f"please ensure that you have provided them directly, via a secrets file or environment "
-                f"variables")
-
-    @classmethod
-    def resolve_api_token(cls, token=None, configuration=None, id_provider_response_handler=None):
-
-        """
-        Description:
-        This method uses a PAT (Personal Access Token) or secrets to return an API token.
-        The method uses the following conditional logic in order of precedence to resolve an
-        authentication path:
-
-            1. Use PAT passed into the function
-            2. Use secrets files passed into the function
-            3. Use environment variables
-
-        PAT are used in preference to supplied credentials.
-        secrets files are used in preference to environment variables.
-
-        :param str token: The pre-populated access token to use instead of asking Okta for a token
-        :param ApiConfiguration configuration: configuration object containing secrets loaded from env vars
-        :param typing.callable id_provider_response_handler: An optional function to handle the Okta response
-
-        :return: str api_token
-        """
-
-        # If token is passed in by user, then use that token
-        if token is not None:
-            cls.__check_required_fields(configuration, ["api_url"])
-            api_token = token
-
-        # If there is a token provided use it
-        elif configuration.access_token is not None:
-            # Check that there is an api_url available
-            cls.__check_required_fields(configuration, ["api_url"])
-            api_token = configuration.access_token
-
-        # Otherwise generate an access token from Okta and use a RefreshingToken going forward
-        else:
-            # Check that all the required fields for generating a token exist
-            cls.__check_required_fields(configuration, [
-                "api_url",
-                "password",
-                "username",
-                "client_id",
-                "client_secret",
-                "token_url"])
-
-            # Generate an access token
-            api_token = RefreshingToken(
-                api_configuration=configuration,
-                id_provider_response_handler=id_provider_response_handler
-            )
-
-        return api_token
-
-    @classmethod
-    def build(cls, api_secrets_filename=None, id_provider_response_handler=None, api_configuration=None,
-              token=None, correlation_id=None, tcp_keep_alive=False):
-        """
-        :param str api_secrets_filename: The full path to the JSON file containing the API credentials and optional proxy details
-        :param typing.callable id_provider_response_handler: An optional function to handle the Okta response
-        :param lusid.utilities.ApiConfiguration api_configuration: A pre-populated ApiConfiguration
-        :param str token: The pre-populated access token to use instead of asking Okta for a token
-        :param str correlation_id: Correlation id for all calls made from the returned ApiClient instance, added as a header to each request
-        :param bool tcp_keep_alive: A flag that controls if the API client uses tcp keep-alive probes
-
-        :return: lusid.ApiClient: The configured LUSID ApiClient
-        """
-
-        # Load the configuration
-        configuration = ApiConfigurationLoader.load(api_secrets_filename)
-
-        # If an api_configuration has been provided override the loaded configuration
-        # with any properties that it has
-        if api_configuration is not None:
-            for key, value in vars(api_configuration).items():
-                if value is not None:
-                    setattr(configuration, key, value)
-
-        api_token = cls.resolve_api_token(token, configuration, id_provider_response_handler)
-
-        # Initialise the API client using the token so that it can be included in all future requests
-        config = Configuration(tcp_keep_alive=tcp_keep_alive)
-        config.access_token = api_token
-        config.host = configuration.api_url
-
-        # Set the certificate from the configuration
-        config.ssl_ca_cert = configuration.certificate_filename
-
-        # Set the proxy for LUSID if needed
-        if configuration.proxy_config is not None:
-            config.proxy = configuration.proxy_config.address
-            if configuration.proxy_config.username is not None and configuration.proxy_config.password is not None:
-                config.proxy_headers = make_headers(
-                    proxy_basic_auth=f"{configuration.proxy_config.username}:{configuration.proxy_config.password}"
-                )
-
-        # Create and return the ApiClient
-        api_client = ApiClient(configuration=config)
-
-        # set the application name if specified
-        if configuration.app_name is not None:
-            api_client.set_default_header("X-LUSID-Application", configuration.app_name)
-
-        # set a correlation id for all requests initiated with this ApiClient
-        corr_id = correlation_id or os.getenv("FBN_CORRELATION_ID")
-        if corr_id is not None:
-            api_client.set_default_header("CorrelationId", corr_id)
-
-        return api_client

lusid/utilities/api_client_factory.py

@@ -1,132 +0,0 @@
-import functools
-import importlib
-import inspect
-
-from lusid import ApiClient
-from lusid.utilities.api_client_builder import ApiClientBuilder
-from lusid.utilities.proxy_config import ProxyConfig
-from lusid.utilities.api_configuration import ApiConfiguration
-from lusid.utilities.lusid_retry import lusidretry
-
-
-class ApiClientFactory:
-    """
-    The ApiClientFactory is responsible for providing the ability to create any of the LUSID APIs using the provided
-    credentials. It will use the same ApiClient across all of the APIs.
-
-    """
-    def __init__(self, **kwargs):
-        """
-        Iniitalise an ApiClientFactory by passing the token, api_url and app_name, or by
-        passing in the api_secrets_filename
-
-        :param str token: Bearer token used to initialise the API
-        :param str api_secrets_filename: Name of secrets file (including full path)
-        :param str api_url: LUSID API url
-        :param str app_name: Application name (optional)
-        :param str certificate_filename: Name of the certificate file (.pem, .cer or .crt)
-        :param str proxy_url: The url of the proxy to use including the port e.g. http://myproxy.com:8888
-        :param str proxy_username: The username for the proxy to use
-        :param str proxy_password: The password for the proxy to use
-        :param str correlation_id: Correlation id for all calls made from the returned LUSID API instances
-        :param bool tcp_keep_alive: A flag for controlling if the API client uses TCP keep-alive probes
-        """
-
-        builder_kwargs = {}
-
-        if "token" in kwargs and str(kwargs["token"]) != "None":
-
-            # If there is a token use it along with the specified proxy details if specified
-            config = ApiConfiguration(
-                api_url=kwargs.get("api_url", None),
-                certificate_filename=kwargs.get("certificate_filename", None),
-                proxy_config=ProxyConfig(
-                    address=kwargs.get("proxy_url", None),
-                    username=kwargs.get("proxy_username", None),
-                    password=kwargs.get("proxy_password", None),
-                ) if kwargs.get("proxy_url", None) is not None else None,
-                app_name=kwargs.get("app_name", None)
-            )
-
-            builder_kwargs["api_configuration"] = config
-            builder_kwargs["token"] = kwargs["token"]
-
-        # Otherwise use a secrets file if it exists
-        builder_kwargs["api_secrets_filename"] = kwargs.get("api_secrets_filename", None)
-
-        # add the correlation id if specified
-        builder_kwargs["correlation_id"] = kwargs.get("correlation_id", None)
-
-        # add the id provider response handler if specified
-        builder_kwargs["id_provider_response_handler"] = kwargs.get("id_provider_response_handler", None)
-
-        builder_kwargs["tcp_keep_alive"] = kwargs.get("tcp_keep_alive", False)
-
-        # Call the client builder, this will result in using either a token, secrets file or environment variables
-        self.api_client = ApiClientBuilder.build(**builder_kwargs)
-
-    def build(self, metaclass):
-        """
-        :param type metaclass:  type of the LUSID API to create
-        :return: Initalised LUSID API for the type passed in
-        """
-
-        def get_attribute_impl(source_obj, name):
-            """
-            Implementation of __getattribute__ that adds a decorator that adds a call_info
-            argument to return additional call stats
-            """
-
-            attr = super(metaclass, source_obj).__getattribute__(name)
-
-            @functools.wraps(attr)
-            @lusidretry
-            def wrapper(*args, **kwargs):
-                def is_http_info_method(m):
-                    return inspect.ismethod(m) and m.__name__.endswith(
-                        "_with_http_info"
-                    )
-
-                if kwargs.get("call_info") is not None:
-                    callback = kwargs.pop("call_info")
-
-                    if not inspect.isfunction(callback):
-                        raise ValueError("call_info value must be a lambda")
-
-                    if is_http_info_method(attr):
-                        result = attr(*args, **kwargs)
-                    else:
-                        #   switch to the '_with_http_info' implementation
-                        func = getattr(source_obj, f"{name}_with_http_info")
-                        result = func(*args, **kwargs)
-
-                    # pass the http info to caller
-                    callback(result[2])
-
-                    # return the dto
-                    return result[0]
-
-                else:
-                    return attr(*args, **kwargs)
-
-            return wrapper if inspect.ismethod(attr) else attr
-
-        def init_impl(dest, src=None):
-            if type(dest) == type(src):
-                dest.__dict__ = src.__dict__
-            elif type(src) == ApiClient:
-                dest.api_client = src
-
-        module = importlib.import_module("lusid.api")
-        api_name = metaclass.__name__
-
-        if not api_name.endswith("Api") or not hasattr(module, api_name):
-            raise TypeError(f"unknown api: {api_name}")
-
-        # create an instance of the api
-        api_impl = getattr(module, api_name)(self.api_client)
-
-        setattr(metaclass, "__getattribute__", get_attribute_impl)
-        setattr(metaclass, "__init__", init_impl)
-
-        return api_impl

lusid/utilities/api_configuration.py

@@ -1,126 +0,0 @@
-import re
-
-
-class ApiConfiguration:
-
-    def __init__(self, token_url=None, api_url=None, username=None, password=None, client_id=None, client_secret=None,
-                 app_name=None, certificate_filename=None, proxy_config=None, access_token=None):
-        """
-        The configuration required to access LUSID, read more at https://support.finbourne.com/getting-started-with-apis-sdks
-
-        :param str token_url: The token URL of the identity provider
-        :param str api_url: The API URL for the LUSID client
-        :param str username: The username to use
-        :param str password: The password to use
-        :param str client_id: The client id to use
-        :param str client_secret: The client secret to use
-        :param str app_name: The name of the application calling LUSID
-        :param str certificate_filename: Name of the certificate file (.pem, .cer or .crt)
-        :param lusid.utilities.ProxyConfig proxy_config: The proxy configuration to use
-        """
-        self.token_url = token_url
-        self.__api_url = api_url
-        self.__username = username
-        self.__password = password
-        self.__client_id = client_id
-        self.__client_secret = client_secret
-        self.__app_name = app_name
-        self.__certificate_filename = certificate_filename
-        self.__proxy_config = proxy_config
-        self.__access_token = access_token
-
-    @property
-    def token_url(self):
-        return self.__token_url
-
-    @token_url.setter
-    def token_url(self, value):
-        def format_token_url(url: str) -> str:
-            """
-            Given an Okta issuer url (ie: https://lusid-testdomain.okta.com/oauth2/asd8f7a98sdf89a7ad), this function
-            will return a full token url (ie: https://lusid-testdomain.okta.com/oauth2/asd8f7a98sdf89a7ad/v1/token)
-            :param url: The url to format
-            :return: An Okta token url (if the input is an Okta issuer url). The original url otherwise.
-            """
-            if (url is not None and
-                    # and it's an Okta oauth2 URL
-                    re.search('^http(s)?:\/\/.*\.okta\.com\/oauth2\/.+', url, flags=re.IGNORECASE) is not None and
-                    # and it's missing the token suffix
-                    re.search('\/v\d+\/token$', url, flags=re.IGNORECASE) is None):
-                return url.rstrip('/') + '/v1/token'
-            return url
-
-        self.__token_url = format_token_url(value)
-
-    @property
-    def api_url(self):
-        return self.__api_url
-
-    @api_url.setter
-    def api_url(self, value):
-        self.__api_url = value
-
-    @property
-    def username(self):
-        return self.__username
-
-    @username.setter
-    def username(self, value):
-        self.__username = value
-
-    @property
-    def password(self):
-        return self.__password
-
-    @password.setter
-    def password(self, value):
-        self.__password = value
-
-    @property
-    def client_id(self):
-        return self.__client_id
-
-    @client_id.setter
-    def client_id(self, value):
-        self.__client_id = value
-
-    @property
-    def client_secret(self):
-        return self.__client_secret
-
-    @client_secret.setter
-    def client_secret(self, value):
-        self.__client_secret = value
-
-    @property
-    def app_name(self):
-        return self.__app_name
-
-    @app_name.setter
-    def app_name(self, value):
-        self.__app_name = value
-
-    @property
-    def certificate_filename(self):
-        return self.__certificate_filename
-
-    @certificate_filename.setter
-    def certificate_filename(self, value):
-        self.__certificate_filename = value
-
-    @property
-    def proxy_config(self):
-        return self.__proxy_config
-
-    @proxy_config.setter
-    def proxy_config(self, value):
-        self.__proxy_config = value
-
-    @property
-    def access_token(self):
-        return self.__access_token
-
-    @access_token.setter
-    def access_token(self, value):
-        self.__access_token = value
-

lusid/utilities/api_configuration_loader.py

@@ -1,87 +0,0 @@
-import json
-import os
-from pathlib import Path
-import logging
-
-from lusid.utilities.api_configuration import ApiConfiguration
-from lusid.utilities.proxy_config import ProxyConfig
-
-
-class ApiConfigurationLoader:
-    """
-    The ApiConfigurationLoader is responsible for populating the API and Proxy configuration from a secrets file or
-    environment variables with preference given to the secrets file.
-    """
-    @staticmethod
-    def load(api_secrets_filename=None):
-        """
-        :param str api_secrets_filename: The full path to the JSON file containing the API credentials and optional proxy details
-
-        :return: lusid.utilities.ApiConfiguration: The populated ApiConfiguration
-        """
-
-        # Get the config keys which contain the mapping between the ApiConfiguration attributes and the variable names
-        # in the secrets.json file and environment variables e.g. token_url is tokenUrl (secrets.json) and
-        # FBN_TOKEN_URL (env variable)
-        with open(Path(__file__).parent.joinpath('config_keys.json')) as json_file:
-            config_keys = json.load(json_file)
-
-        # The secrets file is a nested dictionary, set the names of the top level keys
-        api_config_key = "api"
-        proxy_config_key = "proxy"
-
-        def _load_config_from_secrets_file():
-
-            # If there is a secrets file specified and it exists get the details from it
-            if api_secrets_filename is not None and os.path.exists(api_secrets_filename) and os.path.isfile(api_secrets_filename):
-                with open(api_secrets_filename, "r") as secrets:
-                    config = json.load(secrets)
-
-            # If there is a secrets file specified and it does not exist log a warning to indicate that the specified file
-            # could not be found and create an empty config
-            elif api_secrets_filename is not None and (not os.path.exists(api_secrets_filename) or not os.path.isfile(api_secrets_filename)):
-                logging.debug(f"Provided secrets file of {api_secrets_filename} can not be found, please ensure you "
-                                 f"have correctly specified the full path to the file or don't provide a secrets file to use "
-                                 f"environment variables instead.")
-                config = {}
-            # If no secrets file is specified just create an empty config
-            else:
-                config = {}
-
-            return config
-
-        def _get_access_api_config():
-
-            config = _load_config_from_secrets_file()
-
-            # Populate the values for the api configuration preferring the secrets file over the environment variables
-            populated_api_config_values = {
-                key: config.get(api_config_key, {}).get(value["config"], os.getenv(value["env"], None))
-                for key, value in config_keys.items() if "proxy" not in key
-            }
-
-            return populated_api_config_values
-
-        def _get_proxy_api_config():
-
-            config = _load_config_from_secrets_file()
-
-            # Populate the values for the proxy preferring the secrets file over the environment variables
-            populated_proxy_values = {
-                key.replace("proxy_", ""): config.get(proxy_config_key, {}).get(value["config"], os.getenv(value["env"], None))
-                for key, value in config_keys.items() if "proxy" in key
-            }
-
-            return populated_proxy_values
-
-        populated_api_config_values = _get_access_api_config()
-        populated_proxy_values = _get_proxy_api_config()
-
-        # If the proxy address is missing ensure that no proxy is used in the ApiConfiguration
-        if populated_proxy_values.get("address", None) is None:
-            populated_api_config_values["proxy_config"] = None
-        # Otherwise create a ProxyConfig to use
-        else:
-            populated_api_config_values["proxy_config"] = ProxyConfig(**populated_proxy_values)
-        # Create and return the ApiConfiguration
-        return ApiConfiguration(**populated_api_config_values)

lusid/utilities/config_keys.json

@@ -1,50 +0,0 @@
-{
-  "token_url": {
-      "env": "FBN_TOKEN_URL",
-      "config": "tokenUrl"
-  },
-  "api_url": {
-      "env": "FBN_LUSID_API_URL",
-      "config": "apiUrl"
-  },
-  "username": {
-      "env": "FBN_USERNAME",
-      "config": "username"
-  },
-  "password": {
-      "env": "FBN_PASSWORD",
-      "config": "password"
-  },
-  "client_id": {
-      "env": "FBN_CLIENT_ID",
-      "config": "clientId"
-  },
-  "client_secret": {
-      "env": "FBN_CLIENT_SECRET",
-      "config": "clientSecret"
-  },
-  "app_name": {
-      "env": "FBN_APP_NAME",
-      "config": "applicationName"
-  },
-  "certificate_filename": {
-      "env": "FBN_CLIENT_CERTIFICATE",
-      "config": "clientCertificate"
-  },
-  "proxy_address": {
-      "env": "FBN_PROXY_ADDRESS",
-      "config": "address"
-  },
-  "proxy_username": {
-      "env": "FBN_PROXY_USERNAME",
-      "config": "username"
-  },
-  "proxy_password": {
-      "env": "FBN_PROXY_PASSWORD",
-      "config": "password"
-  },
-    "access_token": {
-      "env": "FBN_ACCESS_TOKEN",
-      "config": "accessToken"
-  }
-}

lusid/utilities/config_keys.py

@@ -1,13 +0,0 @@
-from pathlib import Path
-import json
-
-
-class ConfigKeys:
-    config_key_path = "config_keys.json"
-
-    @classmethod
-    def get(cls):
-        with open(Path(__file__).parent.joinpath(cls.config_key_path)) as json_file:
-            config_keys = json.load(json_file)
-
-        return config_keys