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

lusid/extensions/configuration_loaders.py

@@ -0,0 +1,300 @@
+import json
+import os
+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_URL",
+    "previous_api_url": "FBN_LUSID_API_URL",
+    "username": "FBN_USERNAME",
+    "password": "FBN_PASSWORD",
+    "client_id": "FBN_CLIENT_ID",
+    "client_secret": "FBN_CLIENT_SECRET",
+    "app_name": "FBN_APP_NAME",
+    "certificate_filename": "FBN_CLIENT_CERTIFICATE",
+    "proxy_address": "FBN_PROXY_ADDRESS",
+    "proxy_username": "FBN_PROXY_USERNAME",
+    "proxy_password": "FBN_PROXY_PASSWORD",
+    "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": "lusidUrl",
+    "previous_api_url": "lusidUrl",
+    "username": "username",
+    "password": "password",
+    "client_id": "clientId",
+    "client_secret": "clientSecret",
+    "app_name": "applicationName",
+    "certificate_filename": "clientCertificate",
+    "proxy_address": "address",
+    "proxy_username": "username",
+    "proxy_password": "password",
+    "access_token": "accessToken",
+    "total_timeout_ms": "totalTimeoutMs",
+    "connect_timeout_ms": "connectTimeoutMs",
+    "read_timeout_ms": "readTimeoutMs",
+    "rate_limit_retries": "rateLimitRetries",
+}
+
+
+class ConfigurationLoader(Protocol):
+    """
+    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.
+    """
+
+    def load_config(self) -> Dict[str, object]:
+        pass
+
+
+class SecretsFileConfigurationLoader:
+    """Configuration Loader for reading secrets from a json secrets file
+    """
+    def __init__(
+        self,
+        api_secrets_file: Union[TextIO, str]
+    ):
+        """Create SecretsFileConfigurationLoader
+
+        Parameters
+        ----------
+        api_secrets_file : Union[TextIO, str]
+            File to load secrets from
+        """
+        self._api_secrets_file = api_secrets_file or ""
+
+    def load_config(self) -> Dict[str, object]:
+        """reads config from the provided secrets file
+
+        Returns
+        -------
+        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
+        logger.debug(f"loading config from secrets file: {self._api_secrets_file}")
+        api_config_key = "api"
+        proxy_config_key = "proxy"
+        try:
+            try:
+                config = json.load(self._api_secrets_file)
+            except AttributeError:
+                with open(self._api_secrets_file) as api_secrets_file:
+                    config = json.load(api_secrets_file)
+        except OSError:
+            logger.warning(f"Unable to open secrets file {self._api_secrets_file}")
+            return {}
+        except json.JSONDecodeError:
+            logger.warning("unable to deserialise contents of secrets file to json")
+            return {}
+
+        api_config_section = config.get(api_config_key, {})
+        populated_api_config_values = {
+            key: api_config_section.get(value)
+            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)
+            for key, value in SECRETS_FILE_CONFIG_KEYS.items()
+            if "proxy" in key
+        }
+        populated_config_dict = {
+            **populated_api_config_values,
+            **populated_proxy_values,
+        }
+        return populated_config_dict
+
+
+class EnvironmentVariablesConfigurationLoader:
+    """ConfigurationLoader which reads config from environment variables
+    """    
+    def load_config(self) -> Dict[str, object]:
+        """reads config from environment variables
+
+        Returns
+        -------
+        Dict[str, object]
+            dictionary that can be loaded into an ApiConfiguration object
+        """
+        logger.debug("loading config from environment variables")
+
+        populated_api_config_values = {
+            key: os.environ.get(value)
+            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()
+            if "proxy" in key
+        }
+        populated_config_dict = {
+            **populated_api_config_values,
+            **populated_proxy_values,
+        }
+        return populated_config_dict
+
+
+class ArgsConfigurationLoader:
+    """ConfigurationLoader which loads in config from kwargs in constructor
+    """
+    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.__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, object]:
+        """load configuration from kwargs passed to constructor
+
+        Returns
+        -------
+        Dict[str, object]
+            dictionary that can be loaded into an ApiConfiguration object
+        """
+        logger.debug("loading config from arguments passed to ArgsConfigurationLoader")
+        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:
+    """Read configuration from config loaders.
+    Update config with values from each loader in order (last write wins).
+
+    Parameters
+    ----------
+    config_loaders : Iterable[ConfigurationLoader]
+        Objects that can be used to fetch config with a load_config function returning a dict.
+
+    Returns
+    -------
+    ApiConfiguration
+        Configuration that can be passed to an ApiClient, RefreshingToken, etc.
+    """
+    config = {}
+
+    for config_loader in config_loaders:
+        loaded_config = {
+            key: value
+            for key, value in config_loader.load_config().items()
+            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 proxy_address is not None:
+        config["proxy_config"] = ProxyConfig(
+            address=proxy_address, username=proxy_username, password=proxy_password
+        )
+    else:
+        config["proxy_config"] = None
+    # Create and return the ApiConfiguration
+    return ApiConfiguration(**config)

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/{utilities → extensions}/proxy_config.py

@@ -1,3 +1,7 @@
+from urllib3 import make_headers
+from typing import Dict
+
+
 class ProxyConfig:
     """
     This class is used to hold the proxy configuration details
@@ -19,9 +23,10 @@ class ProxyConfig:
 
     @address.setter
     def address(self, address):
-
         if "http://" not in address and "https://" not in address:
-            raise ValueError(f"The provided proxy address of {address} does not contain a protocol, please specify in the full format e.g. http://myproxy.com:8080")
+            raise ValueError(
+                f"The provided proxy address of {address} does not contain a protocol, please specify in the full format e.g. http://myproxy.com:8080"
+            )
 
         self.__address = address
 
@@ -48,7 +53,20 @@ class ProxyConfig:
 
             proxy_url = f"{self.address[0:index + 3]}{self.username}:{self.password}@{self.address[index + 3:]}"
 
-        return {
-            "http": proxy_url,
-            "https": proxy_url
-        }
+        return {"http": proxy_url, "https": proxy_url}
+
+    @property
+    def headers(self) -> Dict[str, str]:
+        """Return Proxy auth headers
+
+        Returns
+        -------
+        Any
+            Proxy auth headers
+        """
+        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/{utilities → extensions}/refreshing_token.py

@@ -7,11 +7,15 @@ from datetime import datetime
 from datetime import timedelta
 from collections import UserString
 from urllib.parse import quote
+import logging
 
+logger = logging.getLogger(__name__)
 
-class RefreshingToken(UserString):
 
-    def __init__(self, api_configuration, expiry_offset=60, id_provider_response_handler=None):
+class RefreshingToken(UserString):
+    def __init__(
+        self, api_configuration, expiry_offset=60, id_provider_response_handler=None
+    ):
         """
         Implementation of UserString that will automatically refresh the token value upon expiry
 
@@ -21,19 +25,37 @@ class RefreshingToken(UserString):
         before it is consumed by the RefreshingToken, mutation of the Response is possible with this handler
         """
 
-        self.token_data = {
-            "expires": None,
-            "access_token": None,
-            "refresh_token": None
-        }
+        self.token_data = {"expires": None, "access_token": None, "refresh_token": None}
         self.expiry_offset = expiry_offset
-        self.api_configuration = api_configuration
+        try:
+            self.password = api_configuration.password
+            self.client_id = api_configuration.client_id
+            self.client_secret = api_configuration.client_secret
+            self.username = api_configuration.username
+            self.token_url = api_configuration.token_url
+            self.proxy_config = api_configuration.proxy_config
+            self.certificate_filename = api_configuration.certificate_filename
+        except AttributeError:
+            logger.debug("Could not access ApiConfig attribute - ensure api_config is an ApiConfiguration object")
+        self._validate_oauth_params()
         self.id_provider_response_handler = id_provider_response_handler
         self.refresh_func = self.get_refresh_token
         self.lock = threading.Lock()
         self.retry_count = 0
         self.retry_limit = 5
         self.backoff_base = 2
+    
+    def _validate_oauth_params(self):
+        if self.password is None:
+            raise ValueError("Password is None. This value must be set for Oauth")
+        if self.client_id is None:
+            raise ValueError("Client Id is None. This value must be set for Oauth")
+        if self.client_secret is None:
+            raise ValueError("Client Secret is None. This value must be set for Oauth")
+        if self.username is None:
+            raise ValueError("Username is None. This value must be set for Oauth")
+        if self.token_url is None:
+            raise ValueError("Token Url is None. This value must be set for Oauth")
 
     def update_token_data(self, id_provider_json):
         """
@@ -43,7 +65,9 @@ class RefreshingToken(UserString):
         """
         self.token_data["access_token"] = id_provider_json["access_token"]
         # Set the expiry just before the actual expiry to ensure no failed requests
-        delta = timedelta(seconds=id_provider_json.get("expires_in", 3600) - self.expiry_offset)
+        delta = timedelta(
+            seconds=id_provider_json.get("expires_in", 3600) - self.expiry_offset
+        )
         self.token_data["expires"] = datetime.utcnow() + delta
         self.token_data["refresh_token"] = id_provider_json["refresh_token"]
 
@@ -54,29 +78,36 @@ class RefreshingToken(UserString):
         :return: The retrieved access token
         """
         # the safe parameter is to ensure that the / character is also encoded
-        encoded_password = quote(self.api_configuration.password, safe='')
-        encoded_client_id = quote(self.api_configuration.client_id, safe='')
-        encoded_client_secret = quote(self.api_configuration.client_secret, safe='')
+        encoded_password = quote(self.password, safe="")
+        encoded_client_id = quote(self.client_id, safe="")
+        encoded_client_secret = quote(self.client_secret, safe="")
 
         # Prepare our authentication request
-        token_request_body = f"grant_type=password&username={self.api_configuration.username}" \
-            f"&password={encoded_password}&scope=openid client groups offline_access" \
+        token_request_body = (
+            f"grant_type=password&username={self.username}"
+            f"&password={encoded_password}&scope=openid client groups offline_access"
             f"&client_id={encoded_client_id}&client_secret={encoded_client_secret}"
+        )
 
-        headers = {"Accept": "application/json", "Content-Type": "application/x-www-form-urlencoded"}
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/x-www-form-urlencoded",
+        }
 
         # extra request args
         kwargs = {"headers": headers}
 
-        if self.api_configuration.proxy_config is not None:
-            kwargs["proxies"] = self.api_configuration.proxy_config.format_proxy_schema()
+        if self.proxy_config is not None:
+            kwargs["proxies"] = self.proxy_config.format_proxy_schema()
 
         # use certificate if supplied
-        if self.api_configuration.certificate_filename is not None:
-            kwargs["verify"] = self.api_configuration.certificate_filename
+        if self.certificate_filename is not None:
+            kwargs["verify"] = self.certificate_filename
 
         # make request to Okta to get an authentication token
-        id_provider_response = requests.post(self.api_configuration.token_url, data=token_request_body, **kwargs)
+        id_provider_response = requests.post(
+            self.token_url, data=token_request_body, **kwargs
+        )
 
         if self.id_provider_response_handler is not None:
             self.id_provider_response_handler(id_provider_response)
@@ -105,17 +136,22 @@ class RefreshingToken(UserString):
         """
 
         # If any data is missing to use a refresh token e.g. on first try, get an access token using credentials
-        if self.token_data["access_token"] is None or self.token_data["expires"] is None or self.token_data["refresh_token"] is None:
+        if (
+            self.token_data["access_token"] is None
+            or self.token_data["expires"] is None
+            or self.token_data["refresh_token"] is None
+        ):
             return self.get_access_token()
 
         # check if the token has expired and refresh if needed
         if self.token_data["expires"] <= datetime.utcnow():
-
-            encoded_client = base64.b64encode(bytes(f"{self.api_configuration.client_id}:{self.api_configuration.client_secret}", 'utf-8'))
+            encoded_client = base64.b64encode(
+                bytes(f"{self.client_id}:{self.client_secret}", "utf-8")
+            )
 
             headers = {
                 "Content-Type": "application/x-www-form-urlencoded",
-                "Authorization": f"Basic {encoded_client.decode('utf-8')}"
+                "Authorization": f"Basic {encoded_client.decode('utf-8')}",
             }
 
             request_body = f"grant_type=refresh_token&scope=openid client groups offline_access&refresh_token={self.token_data['refresh_token']}"
@@ -123,20 +159,25 @@ class RefreshingToken(UserString):
             # request parameters
             kwargs = {"headers": headers}
 
-            if self.api_configuration.proxy_config is not None:
-                kwargs["proxies"] = self.api_configuration.proxy_config.format_proxy_schema()
+            if self.proxy_config is not None:
+                kwargs["proxies"] = self.proxy_config.format_proxy_schema()
 
-            if self.api_configuration.certificate_filename is not None:
-                kwargs["verify"] = self.api_configuration.certificate_filename
+            if self.certificate_filename is not None:
+                kwargs["verify"] = self.certificate_filename
 
-            id_provider_response = requests.post(self.api_configuration.token_url, data=request_body, **kwargs)
+            id_provider_response = requests.post(
+                self.token_url, data=request_body, **kwargs
+            )
 
             if self.id_provider_response_handler is not None:
                 self.id_provider_response_handler(id_provider_response)
 
             # Refresh token may be expired, if so, get new request token
-            if id_provider_response.status_code == 400 and 'refresh token is invalid or expired' \
-                    in id_provider_response.json()['error_description']:
+            if (
+                id_provider_response.status_code == 400
+                and "refresh token is invalid or expired"
+                in id_provider_response.json()["error_description"]
+            ):
                 return self.get_access_token()
             elif id_provider_response.status_code == 429:
                 self._handle_retry(id_provider_response)
@@ -165,7 +206,9 @@ class RefreshingToken(UserString):
         :param requests.Response id_provider_response: The response from the identity provider
         """
         if self.retry_count >= self.retry_limit:
-            raise ValueError(f"Max retry limit of {self.retry_limit} reached with response of {id_provider_response.json()}")
+            raise ValueError(
+                f"Max retry limit of {self.retry_limit} reached with response of {id_provider_response.json()}"
+            )
 
         self.retry_count += 1
 
@@ -177,7 +220,12 @@ class RefreshingToken(UserString):
                 wait_time = int(retry_value)
             except ValueError:
                 # http date always in GMT
-                wait_time = int(datetime.strptime(retry_value, '%a, %d %b %Y %H:%M:%S GMT').timestamp() - datetime.utcnow().timestamp())
+                wait_time = int(
+                    datetime.strptime(
+                        retry_value, "%a, %d %b %Y %H:%M:%S GMT"
+                    ).timestamp()
+                    - datetime.utcnow().timestamp()
+                )
                 if wait_time <= 0:  # Won't wait for a negative period
                     return
 
@@ -197,10 +245,9 @@ class RefreshingToken(UserString):
 
         :return: int: The number of seconds to wait
         """
-        return backoff_base ** retries
+        return backoff_base**retries
 
     def __getattribute__(self, item):
-
         # return the value of the string
         if item == "data":
             self.lock.acquire()