lusid-sdk 2.0.50b0__py3-none-any.whl → 2.1.684__py3-none-any.whl

lusid/extensions/configuration_loaders.py

@@ -1,15 +1,18 @@
 import json
 import os
-from typing import Dict, TextIO, Protocol, Union, Iterable
+from typing import Dict, TextIO, Protocol, Union, Iterable, Optional
 import logging
 from lusid.extensions.proxy_config import ProxyConfig
 from lusid.extensions.api_configuration import ApiConfiguration
+from lusid.extensions.file_access_token import FileAccessToken
+from lusid.extensions.configuration_options import ConfigurationOptions
 
 logger = logging.getLogger(__name__)
 
 ENVIRONMENT_CONFIG_KEYS = {
     "token_url": "FBN_TOKEN_URL",
-    "api_url": "FBN_LUSID_API_URL",
+    "api_url": "FBN_LUSID_URL",
+    "previous_api_url": "FBN_LUSID_API_URL",
     "username": "FBN_USERNAME",
     "password": "FBN_PASSWORD",
     "client_id": "FBN_CLIENT_ID",
@@ -19,12 +22,17 @@ ENVIRONMENT_CONFIG_KEYS = {
     "proxy_address": "FBN_PROXY_ADDRESS",
     "proxy_username": "FBN_PROXY_USERNAME",
     "proxy_password": "FBN_PROXY_PASSWORD",
-    "access_token": "FBN_ACCESS_TOKEN"
+    "access_token": "FBN_ACCESS_TOKEN",
+    "total_timeout_ms": "FBN_TOTAL_TIMEOUT_MS",
+    "connect_timeout_ms": "FBN_CONNECT_TIMEOUT_MS",
+    "read_timeout_ms": "FBN_READ_TIMEOUT_MS",
+    "rate_limit_retries": "FBN_RATE_LIMIT_RETRIES",
 }
 
 SECRETS_FILE_CONFIG_KEYS = {
     "token_url": "tokenUrl",
-    "api_url": "apiUrl",
+    "api_url": "lusidUrl",
+    "previous_api_url": "lusidUrl",
     "username": "username",
     "password": "password",
     "client_id": "clientId",
@@ -34,7 +42,11 @@ SECRETS_FILE_CONFIG_KEYS = {
     "proxy_address": "address",
     "proxy_username": "username",
     "proxy_password": "password",
-    "access_token": "accessToken"
+    "access_token": "accessToken",
+    "total_timeout_ms": "totalTimeoutMs",
+    "connect_timeout_ms": "connectTimeoutMs",
+    "read_timeout_ms": "readTimeoutMs",
+    "rate_limit_retries": "rateLimitRetries",
 }
 
 
@@ -44,7 +56,7 @@ class ConfigurationLoader(Protocol):
     environment variables with preference given to the secrets file.
     """
 
-    def load_config(self) -> Dict[str, str]:
+    def load_config(self) -> Dict[str, object]:
         pass
 
 
@@ -64,12 +76,12 @@ class SecretsFileConfigurationLoader:
         """
         self._api_secrets_file = api_secrets_file or ""
 
-    def load_config(self) -> Dict[str, str]:
+    def load_config(self) -> Dict[str, object]:
         """reads config from the provided secrets file
 
         Returns
         -------
-        Dict[str, str]
+        Dict[str, object]
             dictionary that can be loaded into an ApiConfiguration object
         """
         # The secrets file is a nested dictionary, set the names of the top level keys
@@ -95,6 +107,9 @@ class SecretsFileConfigurationLoader:
             for key, value in SECRETS_FILE_CONFIG_KEYS.items()
             if "proxy" not in key
         }
+        if not populated_api_config_values["api_url"]:
+            populated_api_config_values["api_url"] = populated_api_config_values["previous_api_url"]
+        del(populated_api_config_values["previous_api_url"])
         proxy_config_section = config.get(proxy_config_key, {})
         populated_proxy_values = {
             key: proxy_config_section.get(value)
@@ -111,12 +126,12 @@ class SecretsFileConfigurationLoader:
 class EnvironmentVariablesConfigurationLoader:
     """ConfigurationLoader which reads config from environment variables
     """    
-    def load_config(self) -> Dict[str, str]:
+    def load_config(self) -> Dict[str, object]:
         """reads config from environment variables
 
         Returns
         -------
-        Dict[str, str]
+        Dict[str, object]
             dictionary that can be loaded into an ApiConfiguration object
         """
         logger.debug("loading config from environment variables")
@@ -126,6 +141,16 @@ class EnvironmentVariablesConfigurationLoader:
             for key, value in ENVIRONMENT_CONFIG_KEYS.items()
             if "proxy" not in key
         }
+        if not populated_api_config_values["api_url"]:
+            populated_api_config_values["api_url"] = populated_api_config_values["previous_api_url"]
+        # ensure that these values are ints
+        for key in ["total_timeout_ms", "connect_timeout_ms", "read_timeout_ms", "rate_limit_retries"]:
+            if populated_api_config_values[key]:
+                try:
+                    populated_api_config_values[key] = int(populated_api_config_values[key])
+                except ValueError as e:
+                    raise ValueError(f"invalid value for '{key}' - value must be an integer if set")
+        del(populated_api_config_values["previous_api_url"])
         populated_proxy_values = {
             key: os.environ.get(value)
             for key, value in ENVIRONMENT_CONFIG_KEYS.items()
@@ -141,27 +166,101 @@ class EnvironmentVariablesConfigurationLoader:
 class ArgsConfigurationLoader:
     """ConfigurationLoader which loads in config from kwargs in constructor
     """
-    def __init__(self, **kwargs):
+    def __init__(self,
+        token_url:Optional[str]=None,
+        api_url:Optional[str]=None,
+        username:Optional[str]=None,
+        password:Optional[str]=None,
+        client_id:Optional[str]=None,
+        client_secret:Optional[str]=None,
+        app_name:Optional[str]=None,
+        certificate_filename:Optional[str]=None,
+        proxy_address:Optional[str]=None,
+        proxy_username:Optional[str]=None,
+        proxy_password:Optional[str]=None,
+        access_token:Optional[str]=None,
+        total_timeout_ms:Optional[int]=None,
+        connect_timeout_ms:Optional[int]=None,
+        read_timeout_ms:Optional[int]=None,
+        rate_limit_retries:Optional[int]=None,
+        ):
         """kwargs passed to this constructor used to build ApiConfiguration
         """
-        self._kwargs = kwargs
+        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_address = proxy_address
+        self.__proxy_username = proxy_username
+        self.__proxy_password = proxy_password
+        self.__access_token = access_token
+        self.__total_timeout_ms = total_timeout_ms
+        self.__connect_timeout_ms = connect_timeout_ms
+        self.__read_timeout_ms = read_timeout_ms
+        self.__rate_limit_retries = rate_limit_retries
 
-    def load_config(self) -> Dict[str, str]:
+    def load_config(self) -> Dict[str, object]:
         """load configuration from kwargs passed to constructor
 
         Returns
         -------
-        Dict[str, str]
+        Dict[str, object]
             dictionary that can be loaded into an ApiConfiguration object
         """
         logger.debug("loading config from arguments passed to ArgsConfigurationLoader")
-        keys = ENVIRONMENT_CONFIG_KEYS.keys()
-        return {key: self._kwargs.get(key) for key in keys}
+        return {
+            "token_url" : self.__token_url, 
+            "api_url" : self.__api_url, 
+            "username" : self.__username, 
+            "password" : self.__password, 
+            "client_id" : self.__client_id, 
+            "client_secret" : self.__client_secret, 
+            "app_name" : self.__app_name, 
+            "certificate_filename" : self.__certificate_filename, 
+            "proxy_address" : self.__proxy_address, 
+            "proxy_username" : self.__proxy_username, 
+            "proxy_password" : self.__proxy_password, 
+            "access_token" : self.__access_token,
+            "total_timeout_ms" : self.__total_timeout_ms,
+            "connect_timeout_ms" : self.__connect_timeout_ms,
+            "read_timeout_ms" : self.__read_timeout_ms,
+            "rate_limit_retries" : self.__rate_limit_retries,
+        }
+
+
+class FileTokenConfigurationLoader:
+    """ConfigurationLoader which loads in access token from file
+        if FBN_ACCESS_TOKEN_FILE is set,
+        or if an access_token_location is passed to the initialiser
+    """
+
+    def __init__(
+        self, access_token_location: str = os.getenv("FBN_ACCESS_TOKEN_FILE", "")
+    ):
+        self.access_token = None
+        # if neither are provided we won't want to override config from other loaders
+        if access_token_location is not None and access_token_location != "":
+            self.access_token = FileAccessToken(access_token_location)
+
+    def load_config(self) -> Dict[str, Union[FileAccessToken, None]]:
+        """load access token from file
+
+        Returns
+        -------
+        Dict[str, str]
+            dictionary that can be loaded into an ApiConfiguration object
+        """
+        return {"access_token": self.access_token}
 
 
 default_config_loaders = (
     EnvironmentVariablesConfigurationLoader(),
     SecretsFileConfigurationLoader(api_secrets_file="secrets.json"),
+    FileTokenConfigurationLoader()
 )
 
 def get_api_configuration(config_loaders: Iterable[ConfigurationLoader]) -> ApiConfiguration:
@@ -184,16 +283,14 @@ def get_api_configuration(config_loaders: Iterable[ConfigurationLoader]) -> ApiC
         loaded_config = {
             key: value
             for key, value in config_loader.load_config().items()
-            if value is not None
+            if value is not None and value != None
         }
         config.update(loaded_config)
     proxy_address = config.pop("proxy_address", None)
     proxy_username = config.pop("proxy_username", None)
     proxy_password = config.pop("proxy_password", None)
     # If the proxy address is missing ensure that no proxy is used in the ApiConfiguration
-    if all(
-        (item is not None for item in (proxy_address, proxy_password, proxy_username))
-    ):
+    if proxy_address is not None:
         config["proxy_config"] = ProxyConfig(
             address=proxy_address, username=proxy_username, password=proxy_password
         )

lusid/extensions/configuration_options.py

@@ -0,0 +1,67 @@
+from typing import Optional
+
+class ConfigurationOptions:
+    
+    def __init__(
+        self, 
+        total_timeout_ms: Optional[int] = None, 
+        connect_timeout_ms: Optional[int] = None, 
+        read_timeout_ms: Optional[int] = None, 
+        rate_limit_retries: Optional[int] = None
+    ):
+        self.total_timeout_ms = total_timeout_ms
+        self.connect_timeout_ms = connect_timeout_ms
+        self.read_timeout_ms = read_timeout_ms
+        self.rate_limit_retries = rate_limit_retries
+        
+    @property
+    def total_timeout_ms(self):
+        return self.__total_timeout_ms
+
+    @total_timeout_ms.setter
+    def total_timeout_ms(self, value):
+        if value:
+            if not isinstance(value, int):
+                raise TypeError(f"total_timeout_ms must be type int but type '{type(value)}' used")
+            if value < 0:
+                raise ValueError(f"total_timeout_ms must be an integer greater than or equal to zero")
+        self.__total_timeout_ms = value
+
+    @property
+    def connect_timeout_ms(self):
+        return self.__connect_timeout_ms
+
+    @connect_timeout_ms.setter
+    def connect_timeout_ms(self, value):
+        if value:
+            if not isinstance(value, int):
+                raise TypeError(f"connect_timeout_ms must be type int but type '{type(value)}' used")
+            if value < 0:
+                raise ValueError(f"connect_timeout_ms must be an integer greater than or equal to zero")
+        self.__connect_timeout_ms = value
+
+    @property
+    def read_timeout_ms(self):
+        return self.__read_timeout_ms
+
+    @read_timeout_ms.setter
+    def read_timeout_ms(self, value):
+        if value:
+            if not isinstance(value, int):
+                raise TypeError(f"read_timeout_ms must be type int but type '{type(value)}' used")
+            if value < 0:
+                raise ValueError(f"read_timeout_ms must be an integer greater than or equal to zero")
+        self.__read_timeout_ms = value
+
+    @property
+    def rate_limit_retries(self):
+        return self.__rate_limit_retries
+
+    @rate_limit_retries.setter
+    def rate_limit_retries(self, value):
+        if value:
+            if not isinstance(value, int):
+                raise TypeError(f"rate_limit_retries must be type int but type '{type(value)}' used")
+            if value < 0:
+                raise ValueError(f"rate_limit_retries must be an integer greater than or equal to zero")
+        self.__rate_limit_retries = value

lusid/extensions/file_access_token.py

@@ -0,0 +1,42 @@
+import collections
+import datetime
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class FileAccessToken(collections.UserString):
+    """Loads access token from file when requested
+    Acts as a string so can be concatenated to auth headers
+    """
+
+    def __init__(self, access_token_location: str, expiry_time:int = 120):
+        if access_token_location is None or access_token_location == "":
+            raise ValueError("access_token_location must be a non-empty string")
+        self.__access_token_location = access_token_location
+        self.__expiry_time = expiry_time 
+        self.__token_data = {
+            "expires": datetime.datetime.now(),
+            "current_access_token": "",
+        }
+
+    @property
+    def data(self) -> str:
+        """load access token from file
+
+        Returns
+        -------
+        str
+            Access token
+        """
+        if self.__token_data["expires"] <= datetime.datetime.now():
+            try:
+                with open(self.__access_token_location, "r") as access_token_file:
+                    self.__token_data["current_access_token"] = access_token_file.read()
+                self.__token_data["expires"] = (
+                    datetime.datetime.now() + datetime.timedelta(seconds=self.__expiry_time)
+                )
+            except OSError:
+                logger.error("Could not open access token file")
+                raise
+        return self.__token_data["current_access_token"]

lusid/extensions/proxy_config.py

@@ -1,5 +1,5 @@
 from urllib3 import make_headers
-from typing import Any
+from typing import Dict
 
 
 class ProxyConfig:
@@ -56,7 +56,7 @@ class ProxyConfig:
         return {"http": proxy_url, "https": proxy_url}
 
     @property
-    def headers(self) -> Any:
+    def headers(self) -> Dict[str, str]:
         """Return Proxy auth headers
 
         Returns
@@ -64,6 +64,9 @@ class ProxyConfig:
         Any
             Proxy auth headers
         """
-        return make_headers(
-            proxy_basic_auth=f"{self.__username}:{self.__password}"
-        )
+        if self.__username is not None and self.__password is not None:
+            return make_headers(
+                proxy_basic_auth=f"{self.__username}:{self.__password}"
+            )
+        else:
+            return {}

lusid/extensions/rest.py

@@ -103,9 +103,15 @@ class RESTClientObject(object):
                 **addition_pool_args
             )
 
+        self.timeout = self.get_timeout(
+            total=configuration.timeouts.total_timeout_ms / 1000.0,
+            connect=configuration.timeouts.connect_timeout_ms / 1000.0,
+            read=configuration.timeouts.read_timeout_ms / 1000.0,
+        )
+
     def request(self, method, url, query_params=None, headers=None,
                 body=None, post_params=None, _preload_content=True,
-                _request_timeout=None):
+                _request_timeout=None, opts=None):
         """Perform requests.
 
         :param method: http request method
@@ -119,10 +125,9 @@ class RESTClientObject(object):
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
         """
         method = method.upper()
         assert method in ['GET', 'HEAD', 'DELETE', 'POST', 'PUT',
@@ -139,14 +144,45 @@ class RESTClientObject(object):
         # so reset query_params to empty dict
         query_params = {}
 
+        # _request_timeout param cannot be removed for backwards compatability
+        # values from opts override values from _request_timeout
+        # try to get values from opts first, then _request_timeout, then self.timeout, else set to None
+        # timeout = _request_timeout or self.timeout
         timeout = None
-        if _request_timeout:
-            if isinstance(_request_timeout, (int,float)):  # noqa: E501,F821
-                timeout = urllib3.Timeout(total=_request_timeout)
-            elif (isinstance(_request_timeout, tuple) and
-                  len(_request_timeout) == 2):
-                timeout = urllib3.Timeout(
-                    connect=_request_timeout[0], read=_request_timeout[1])
+        opts_total_timeout = opts.total_timeout_ms / 1000.0 if opts and opts.total_timeout_ms != None else None
+        opts_connect_timeout = opts.connect_timeout_ms / 1000.0 if opts and opts.connect_timeout_ms != None else None
+        opts_read_timeout = opts.read_timeout_ms / 1000.0 if opts and opts.read_timeout_ms != None else None
+        if not _request_timeout:
+            timeout = self.get_timeout(
+                total=opts_total_timeout if opts_total_timeout != None
+                    else self.timeout.total, 
+                connect=opts_connect_timeout if opts_connect_timeout != None
+                    else self.timeout._connect,
+                read=opts_read_timeout if opts_read_timeout != None
+                    else self.timeout._read)
+        elif isinstance(_request_timeout, urllib3.Timeout):
+            timeout = self.get_timeout(
+                total=opts_total_timeout if opts_total_timeout != None
+                    else _request_timeout.total if _request_timeout.total != None
+                        else self.timeout.total, 
+                connect=opts_connect_timeout if opts_connect_timeout != None
+                    else _request_timeout._connect if _request_timeout._connect != None
+                        else self.timeout._connect,
+                read=opts_read_timeout if opts_read_timeout != None
+                    else _request_timeout._read if _request_timeout._read != None
+                        else self.timeout._read)
+        elif isinstance(_request_timeout, (int, float)):
+            timeout = self.get_timeout(
+                total=opts_total_timeout if opts_total_timeout != None else _request_timeout, 
+                connect=opts_connect_timeout if opts_connect_timeout != None else self.timeout._connect, 
+                read=opts_read_timeout if opts_read_timeout != None else self.timeout._read)
+        elif (isinstance(_request_timeout, tuple) and len(_request_timeout) == 2):
+            timeout = self.get_timeout(
+                total=opts_total_timeout if opts_total_timeout != None else self.timeout.total,
+                connect=opts_connect_timeout if opts_connect_timeout != None else _request_timeout[0],
+                read=opts_read_timeout if opts_read_timeout != None else _request_timeout[1])
+        else:
+            raise f"unexpected type '{type(_request_timeout)}' for _request_timeout"
 
         try:
             # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
@@ -235,66 +271,82 @@ class RESTClientObject(object):
         return r
 
     def get_request(self, url, headers=None, query_params=None, _preload_content=True,
-            _request_timeout=None):
+            _request_timeout=None, opts=None):
         return self.request("GET", url,
                             headers=headers,
                             _preload_content=_preload_content,
                             _request_timeout=_request_timeout,
-                            query_params=query_params)
+                            query_params=query_params,
+                            opts=opts)
 
     def head_request(self, url, headers=None, query_params=None, _preload_content=True,
-             _request_timeout=None):
+             _request_timeout=None, opts=None):
         return self.request("HEAD", url,
                             headers=headers,
                             _preload_content=_preload_content,
                             _request_timeout=_request_timeout,
-                            query_params=query_params)
+                            query_params=query_params,
+                            opts=opts)
 
     def options_request(self, url, headers=None, query_params=None, post_params=None,
-                body=None, _preload_content=True, _request_timeout=None):
+                body=None, _preload_content=True, _request_timeout=None, opts=None):
         return self.request("OPTIONS", url,
                             headers=headers,
                             query_params=query_params,
                             post_params=post_params,
                             _preload_content=_preload_content,
                             _request_timeout=_request_timeout,
-                            body=body)
+                            body=body,
+                            opts=opts)
 
     def delete_request(self, url, headers=None, query_params=None, body=None,
-               _preload_content=True, _request_timeout=None):
+               _preload_content=True, _request_timeout=None, opts=None):
         return self.request("DELETE", url,
                             headers=headers,
                             query_params=query_params,
                             _preload_content=_preload_content,
                             _request_timeout=_request_timeout,
-                            body=body)
+                            body=body,
+                            opts=opts)
 
     def post_request(self, url, headers=None, query_params=None, post_params=None,
-             body=None, _preload_content=True, _request_timeout=None):
+             body=None, _preload_content=True, _request_timeout=None, opts=None):
         return self.request("POST", url,
                             headers=headers,
                             query_params=query_params,
                             post_params=post_params,
                             _preload_content=_preload_content,
                             _request_timeout=_request_timeout,
-                            body=body)
+                            body=body,
+                            opts=opts)
 
     def put_request(self, url, headers=None, query_params=None, post_params=None,
-            body=None, _preload_content=True, _request_timeout=None):
+            body=None, _preload_content=True, _request_timeout=None, opts=None):
         return self.request("PUT", url,
                             headers=headers,
                             query_params=query_params,
                             post_params=post_params,
                             _preload_content=_preload_content,
                             _request_timeout=_request_timeout,
-                            body=body)
+                            body=body,
+                            opts=opts)
 
     def patch_request(self, url, headers=None, query_params=None, post_params=None,
-              body=None, _preload_content=True, _request_timeout=None):
+              body=None, _preload_content=True, _request_timeout=None, opts=None):
         return self.request("PATCH", url,
                             headers=headers,
                             query_params=query_params,
                             post_params=post_params,
                             _preload_content=_preload_content,
                             _request_timeout=_request_timeout,
-                            body=body)
+                            body=body,
+                            opts=opts)
+
+    def get_timeout(self, total: int, connect: int, read: int):
+        # zero is used in the sdk config to explicitly set to infinity (and None is used to indicate the value has not been set)
+        # but zero is not an allowed value for urllib3.Timeout so change any zeros to Nones
+        return urllib3.Timeout(
+            total=total if total != 0 else None,
+            connect=connect if connect != 0 else None,
+            read=read if read != 0 else None,
+        )