lusid-sdk 2.1.405__py3-none-any.whl → 2.1.537__py3-none-any.whl

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/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,
+        )

lusid/extensions/retry.py

@@ -1,19 +1,33 @@
 import time
-from typing import overload
+from typing import Optional
 
-from lusid import ApiException
 import asyncio
 
+from lusid.configuration import Configuration
+from lusid.exceptions import ApiException
+
 
 class RetryingRestWrapper:
     """Wrapper for HTTP requests
     Which retries on failure
     And waits the amount of time specified in the Retry After header.
     """
-    def __init__(self, rest_object, retries: int = 3):
+    def __init__(
+        self, 
+        rest_object, 
+        retries: int = Configuration.DEFAULT_RETRIES, 
+        rate_limit_retries: int = Configuration.DEFAULT_RATE_LIMIT_RETRIES
+    ):
         if not isinstance(retries, int):
-            raise ValueError(f"retries should be an int, found {type(self.retries)}")
+            raise TypeError(f"retries should be an int, found {type(retries)}")
+        if retries < 0:
+            raise ValueError(f"retries should be greater than or equal to zero but was '{retries}'")
+        if not isinstance(rate_limit_retries, int):
+            raise TypeError(f"rate_limit_retries should be an int, found {type(rate_limit_retries)}")
+        if rate_limit_retries < 0:
+            raise ValueError(f"rate_limit_retries should be greater than or equal to zero but was '{rate_limit_retries}'")
         self.retries: int = retries
+        self.rate_limit_retries: int = rate_limit_retries
         self.rest_object = rest_object
 
     def request(
@@ -26,9 +40,12 @@ class RetryingRestWrapper:
         post_params=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
-        tries = 0
-        while tries < self.retries + 1:
+        retries_count = 0
+        rate_limit_retries_count = 0
+
+        while True:
             try:
                 return self.rest_object.request(
                     method,
@@ -39,17 +56,26 @@ class RetryingRestWrapper:
                     post_params,
                     _preload_content,
                     _request_timeout,
+                    opts,
                 )
             except ApiException as ex:
-                
-                retry_after = ex.headers.get("Retry-After")
 
-                # have done max number of retries
-                if tries >= self.retries:
-                    raise
+                if ex.status == 429 and ((opts != None and opts.rate_limit_retries != None) or self.rate_limit_retries != None):
+                    # check for limit of rate limit retries
+                    limit = opts.rate_limit_retries if (opts and opts.rate_limit_retries != None) else self.rate_limit_retries
+                    if rate_limit_retries_count >= limit:
+                        raise
+                    rate_limit_retries_count += 1
+                else:
+                    # check for limit of all other retries
+                    if retries_count >= self.retries:
+                        raise
+                    retries_count += 1
+
+                retry_after = ex.headers.get("Retry-After")
 
                 # try after delay
-                elif retry_after is not None:
+                if retry_after is not None:
                     if not isinstance(retry_after, float):
                         try:
                             retry_after = float(retry_after)
@@ -61,7 +87,6 @@ class RetryingRestWrapper:
                 # no retry header
                 else:
                     raise
-                tries += 1
 
     def get_request(
         self,
@@ -70,12 +95,14 @@ class RetryingRestWrapper:
         query_params=None,
         _preload_content=True,
         _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,
@@ -84,12 +111,14 @@ class RetryingRestWrapper:
         query_params=None,
         _preload_content=True,
         _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,
@@ -100,6 +129,7 @@ class RetryingRestWrapper:
         body=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
         return self.request("OPTIONS", url,
                             headers=headers,
@@ -107,7 +137,8 @@ class RetryingRestWrapper:
                             post_params=post_params,
                             _preload_content=_preload_content,
                             _request_timeout=_request_timeout,
-                            body=body)
+                            body=body,
+                            opts=opts)
 
     def delete_request(
         self,
@@ -117,13 +148,15 @@ class RetryingRestWrapper:
         body=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,
@@ -134,6 +167,7 @@ class RetryingRestWrapper:
         body=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
         return self.request("POST", url,
                             headers=headers,
@@ -141,7 +175,8 @@ class RetryingRestWrapper:
                             post_params=post_params,
                             _preload_content=_preload_content,
                             _request_timeout=_request_timeout,
-                            body=body)
+                            body=body,
+                            opts=opts)
 
     def put_request(
         self,
@@ -152,6 +187,7 @@ class RetryingRestWrapper:
         body=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
         return self.request("PUT", url,
                             headers=headers,
@@ -159,7 +195,8 @@ class RetryingRestWrapper:
                             post_params=post_params,
                             _preload_content=_preload_content,
                             _request_timeout=_request_timeout,
-                            body=body)
+                            body=body,
+                            opts=opts)
 
     def patch_request(
         self,
@@ -170,6 +207,7 @@ class RetryingRestWrapper:
         body=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
         return self.request("PATCH", url,
                             headers=headers,
@@ -177,7 +215,8 @@ class RetryingRestWrapper:
                             post_params=post_params,
                             _preload_content=_preload_content,
                             _request_timeout=_request_timeout,
-                            body=body)
+                            body=body,
+                            opts=opts)
 
 
 class RetryingRestWrapperAsync:
@@ -185,10 +224,17 @@ class RetryingRestWrapperAsync:
     Which retries on failure
     And waits the amount of time specified in the Retry After header.
     """
-    def __init__(self, rest_object, retries: int = 3):
+    def __init__(self, rest_object, retries: int = 3, rate_limit_retries: Optional[int] = Configuration.DEFAULT_RATE_LIMIT_RETRIES):
         if not isinstance(retries, int):
-            raise ValueError(f"retries should be an int, found {type(self.retries)}")
+            raise TypeError(f"retries should be an int, found {type(retries)}")
+        if retries < 0:
+            raise ValueError(f"retries should be greater than or equal to zero but was '{retries}'")
+        if not isinstance(rate_limit_retries, int):
+            raise TypeError(f"rate_limit_retries should be an int, found {type(rate_limit_retries)}")
+        if rate_limit_retries < 0:
+            raise ValueError(f"rate_limit_retries should be greater than or equal to zero but was '{rate_limit_retries}'")
         self.retries: int = retries
+        self.rate_limit_retries: Optional[int] = rate_limit_retries
         self.rest_object = rest_object
 
     async def close(self):
@@ -204,9 +250,12 @@ class RetryingRestWrapperAsync:
         post_params=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
-        tries = 0
-        while tries < self.retries + 1:
+        retries_count = 0
+        rate_limit_retries_count = 0
+        
+        while True:
             try:
                 return await self.rest_object.request(
                     method,
@@ -217,16 +266,26 @@ class RetryingRestWrapperAsync:
                     post_params,
                     _preload_content,
                     _request_timeout,
+                    opts
                 )
             except ApiException as ex:
-                retry_after = ex.headers.get("Retry-After")
 
-                # have done max number of retries
-                if tries >= self.retries:
-                    raise
+                if ex.status == 429 and ((opts and opts.rate_limit_retries != None) or self.rate_limit_retries != None):
+                    # check for limit of rate limit retries
+                    limit = opts.rate_limit_retries if (opts and opts.rate_limit_retries != None) else self.rate_limit_retries
+                    if rate_limit_retries_count >= limit:
+                        raise
+                    rate_limit_retries_count += 1
+                else:
+                    # check for limit of all other retries
+                    if retries_count >= self.retries:
+                        raise
+                    retries_count += 1
+
+                retry_after = ex.headers.get("Retry-After")
 
                 # try after delay
-                elif retry_after is not None:
+                if retry_after is not None:
                     if not isinstance(retry_after, float):
                         try:
                             retry_after = float(retry_after)
@@ -238,7 +297,6 @@ class RetryingRestWrapperAsync:
                 # no retry header
                 else:
                     raise
-                tries += 1
 
     async def get_request(
         self,
@@ -247,12 +305,14 @@ class RetryingRestWrapperAsync:
         query_params=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
         return (await self.request("GET", url,
                                    headers=headers,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   query_params=query_params))
+                                   query_params=query_params,
+                                   opts=opts))
 
     async def head_request(
         self,
@@ -261,12 +321,14 @@ class RetryingRestWrapperAsync:
         query_params=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
         return (await self.request("HEAD", url,
                                    headers=headers,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   query_params=query_params))
+                                   query_params=query_params,
+                                   opts=opts))
 
     async def options_request(
         self,
@@ -277,6 +339,7 @@ class RetryingRestWrapperAsync:
         body=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
         return (await self.request("OPTIONS", url,
                                    headers=headers,
@@ -284,7 +347,8 @@ class RetryingRestWrapperAsync:
                                    post_params=post_params,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   body=body))
+                                   body=body,
+                                   opts=opts))
 
     async def delete_request(
         self,
@@ -294,13 +358,15 @@ class RetryingRestWrapperAsync:
         body=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
         return (await self.request("DELETE", url,
                                    headers=headers,
                                    query_params=query_params,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   body=body))
+                                   body=body,
+                                   opts=opts))
 
     async def post_request(
         self,
@@ -311,6 +377,7 @@ class RetryingRestWrapperAsync:
         body=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
         return (await self.request("POST", url,
                                    headers=headers,
@@ -318,7 +385,8 @@ class RetryingRestWrapperAsync:
                                    post_params=post_params,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   body=body))
+                                   body=body,
+                                   opts=opts))
 
     async def put_request(
         self,
@@ -329,6 +397,7 @@ class RetryingRestWrapperAsync:
         body=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
         return (await self.request("PUT", url,
                                    headers=headers,
@@ -336,7 +405,8 @@ class RetryingRestWrapperAsync:
                                    post_params=post_params,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   body=body))
+                                   body=body,
+                                   opts=opts))
 
     async def patch_request(
         self,
@@ -347,6 +417,7 @@ class RetryingRestWrapperAsync:
         body=None,
         _preload_content=True,
         _request_timeout=None,
+        opts=None,
     ):
         return (await self.request("PATCH", url,
                                    headers=headers,
@@ -354,4 +425,5 @@ class RetryingRestWrapperAsync:
                                    post_params=post_params,
                                    _preload_content=_preload_content,
                                    _request_timeout=_request_timeout,
-                                   body=body))
+                                   body=body,
+                                   opts=opts))