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

lusid/extensions/retry.py

@@ -0,0 +1,357 @@
+import time
+from typing import overload
+
+from lusid import ApiException
+import asyncio
+
+
+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):
+        if not isinstance(retries, int):
+            raise ValueError(f"retries should be an int, found {type(self.retries)}")
+        self.retries: int = retries
+        self.rest_object = rest_object
+
+    def request(
+        self,
+        method,
+        url,
+        query_params=None,
+        headers=None,
+        body=None,
+        post_params=None,
+        _preload_content=True,
+        _request_timeout=None,
+    ):
+        tries = 0
+        while tries < self.retries + 1:
+            try:
+                return self.rest_object.request(
+                    method,
+                    url,
+                    query_params,
+                    headers,
+                    body,
+                    post_params,
+                    _preload_content,
+                    _request_timeout,
+                )
+            except ApiException as ex:
+                
+                retry_after = ex.headers.get("Retry-After")
+
+                # have done max number of retries
+                if tries >= self.retries:
+                    raise
+
+                # try after delay
+                elif retry_after is not None:
+                    if not isinstance(retry_after, float):
+                        try:
+                            retry_after = float(retry_after)
+                        except ValueError:
+                            raise ValueError(
+                                f"invalid Retry-After header value: {retry_after}"
+                            )
+                    time.sleep(retry_after)
+                # no retry header
+                else:
+                    raise
+                tries += 1
+
+    def get_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        _preload_content=True,
+        _request_timeout=None,
+    ):
+        return self.request("GET", url,
+                            headers=headers,
+                            _preload_content=_preload_content,
+                            _request_timeout=_request_timeout,
+                            query_params=query_params)
+
+    def head_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        _preload_content=True,
+        _request_timeout=None,
+    ):
+        return self.request("HEAD", url,
+                            headers=headers,
+                            _preload_content=_preload_content,
+                            _request_timeout=_request_timeout,
+                            query_params=query_params)
+
+    def options_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        post_params=None,
+        body=None,
+        _preload_content=True,
+        _request_timeout=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)
+
+    def delete_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        body=None,
+        _preload_content=True,
+        _request_timeout=None,
+    ):
+        return self.request("DELETE", url,
+                            headers=headers,
+                            query_params=query_params,
+                            _preload_content=_preload_content,
+                            _request_timeout=_request_timeout,
+                            body=body)
+
+    def post_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        post_params=None,
+        body=None,
+        _preload_content=True,
+        _request_timeout=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)
+
+    def put_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        post_params=None,
+        body=None,
+        _preload_content=True,
+        _request_timeout=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)
+
+    def patch_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        post_params=None,
+        body=None,
+        _preload_content=True,
+        _request_timeout=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)
+
+
+class RetryingRestWrapperAsync:
+    """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):
+        if not isinstance(retries, int):
+            raise ValueError(f"retries should be an int, found {type(self.retries)}")
+        self.retries: int = retries
+        self.rest_object = rest_object
+
+    async def close(self):
+        await self.rest_object.close()
+
+    async def request(
+        self,
+        method,
+        url,
+        query_params=None,
+        headers=None,
+        body=None,
+        post_params=None,
+        _preload_content=True,
+        _request_timeout=None,
+    ):
+        tries = 0
+        while tries < self.retries + 1:
+            try:
+                return await self.rest_object.request(
+                    method,
+                    url,
+                    query_params,
+                    headers,
+                    body,
+                    post_params,
+                    _preload_content,
+                    _request_timeout,
+                )
+            except ApiException as ex:
+                retry_after = ex.headers.get("Retry-After")
+
+                # have done max number of retries
+                if tries >= self.retries:
+                    raise
+
+                # try after delay
+                elif retry_after is not None:
+                    if not isinstance(retry_after, float):
+                        try:
+                            retry_after = float(retry_after)
+                        except ValueError:
+                            raise ValueError(
+                                f"invalid Retry-After header value: {retry_after}"
+                            )
+                    await asyncio.sleep(retry_after)
+                # no retry header
+                else:
+                    raise
+                tries += 1
+
+    async def get_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        _preload_content=True,
+        _request_timeout=None,
+    ):
+        return (await self.request("GET", url,
+                                   headers=headers,
+                                   _preload_content=_preload_content,
+                                   _request_timeout=_request_timeout,
+                                   query_params=query_params))
+
+    async def head_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        _preload_content=True,
+        _request_timeout=None,
+    ):
+        return (await self.request("HEAD", url,
+                                   headers=headers,
+                                   _preload_content=_preload_content,
+                                   _request_timeout=_request_timeout,
+                                   query_params=query_params))
+
+    async def options_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        post_params=None,
+        body=None,
+        _preload_content=True,
+        _request_timeout=None,
+    ):
+        return (await self.request("OPTIONS", url,
+                                   headers=headers,
+                                   query_params=query_params,
+                                   post_params=post_params,
+                                   _preload_content=_preload_content,
+                                   _request_timeout=_request_timeout,
+                                   body=body))
+
+    async def delete_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        body=None,
+        _preload_content=True,
+        _request_timeout=None,
+    ):
+        return (await self.request("DELETE", url,
+                                   headers=headers,
+                                   query_params=query_params,
+                                   _preload_content=_preload_content,
+                                   _request_timeout=_request_timeout,
+                                   body=body))
+
+    async def post_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        post_params=None,
+        body=None,
+        _preload_content=True,
+        _request_timeout=None,
+    ):
+        return (await self.request("POST", url,
+                                   headers=headers,
+                                   query_params=query_params,
+                                   post_params=post_params,
+                                   _preload_content=_preload_content,
+                                   _request_timeout=_request_timeout,
+                                   body=body))
+
+    async def put_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        post_params=None,
+        body=None,
+        _preload_content=True,
+        _request_timeout=None,
+    ):
+        return (await self.request("PUT", url,
+                                   headers=headers,
+                                   query_params=query_params,
+                                   post_params=post_params,
+                                   _preload_content=_preload_content,
+                                   _request_timeout=_request_timeout,
+                                   body=body))
+
+    async def patch_request(
+        self,
+        url,
+        headers=None,
+        query_params=None,
+        post_params=None,
+        body=None,
+        _preload_content=True,
+        _request_timeout=None,
+    ):
+        return (await self.request("PATCH", url,
+                                   headers=headers,
+                                   query_params=query_params,
+                                   post_params=post_params,
+                                   _preload_content=_preload_content,
+                                   _request_timeout=_request_timeout,
+                                   body=body))

lusid/extensions/socket_keep_alive.py

@@ -0,0 +1,53 @@
+from typing import Sequence
+import socket
+import logging
+from urllib3.connection import HTTPConnection
+
+__logger__ = logging.getLogger(__name__)
+
+
+def keep_alive_socket_options() -> Sequence:
+    """Returns default socket options for all platforms for
+    setting keep alives on tcp connections.
+
+    Returns
+    -------
+    Sequence
+        Set of socket options.
+    """
+    # 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
+
+    try:
+        # linux and some windows runtimes
+        return HTTPConnection.default_socket_options + [
+            (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
+            (socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, TCP_KEEP_IDLE),
+            (socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, TCP_KEEPALIVE_INTERVAL),
+            (socket.IPPROTO_TCP, socket.TCP_KEEPCNT, TCP_KEEP_CNT),
+        ]
+    except AttributeError:
+        pass
+    try:
+        # other windows runtimes
+        return HTTPConnection.default_socket_options + [
+            socket.SIO_KEEPALIVE_VALS,
+            (1, TCP_KEEP_IDLE * 1000, TCP_KEEPALIVE_INTERVAL * 1000),
+        ]
+    except AttributeError:
+        pass
+    try:
+        # darwin
+        return HTTPConnection.default_socket_options + [
+            (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
+            (socket.IPPROTO_TCP, TCP_KEEPALIVE, TCP_KEEPALIVE_INTERVAL),
+        ]
+    except AttributeError:
+        __logger__.exception("Unable to set TCP Keep-alive socket options")
+        raise

lusid/extensions/tcp_keep_alive_connector.py

@@ -0,0 +1,66 @@
+from ssl import SSLContext
+import aiohttp
+import asyncio
+from typing import List, Tuple, Any, Union, Optional
+
+
+class TcpKeepAliveConnector(aiohttp.TCPConnector):
+    """Replacement for aiohttp.TCPConnector
+    which sets socket options on each connection.
+    So we can use tcp keep alives which aiohttp has limited support for.
+    """
+    def __init__(
+        self,
+        *,
+        verify_ssl: bool = True,
+        fingerprint: Optional[bytes] = None,
+        use_dns_cache: bool = True,
+        ttl_dns_cache: Optional[int] = 10,
+        family: int = 0,
+        ssl_context: Optional[SSLContext] = None,
+        ssl: Union[None, bool, aiohttp.Fingerprint, SSLContext] = None,
+        local_addr: Optional[Tuple[str, int]] = None,
+        resolver: Optional[aiohttp.abc.AbstractResolver] = None,
+        keepalive_timeout: Union[None, float, object] = aiohttp.helpers.sentinel,
+        force_close: bool = False,
+        limit: int = 100,
+        limit_per_host: int = 0,
+        enable_cleanup_closed: bool = False,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        socket_options: Union[Tuple[Any, Any, Any], Tuple[Any, Any, None, int]]
+    ) -> None:
+        super().__init__(
+            verify_ssl=verify_ssl,
+            fingerprint=fingerprint,
+            use_dns_cache=use_dns_cache,
+            ttl_dns_cache=ttl_dns_cache,
+            family=family,
+            ssl_context=ssl_context,
+            ssl=ssl,
+            local_addr=local_addr,
+            resolver=resolver,
+            keepalive_timeout=keepalive_timeout,
+            force_close=force_close,
+            limit=limit,
+            limit_per_host=limit_per_host,
+            enable_cleanup_closed=enable_cleanup_closed,
+            loop=loop,
+        )
+        self.socket_options = socket_options or []
+
+    async def _create_connection(
+        self,
+        req: aiohttp.ClientRequest,
+        traces: List[aiohttp.tracing.Trace],
+        timeout: aiohttp.ClientTimeout,
+    ) -> aiohttp.client_proto.ResponseHandler:
+        if req.proxy:
+            transport, proto = await self._create_proxy_connection(req, traces, timeout)
+        else:
+            transport, proto = await self._create_direct_connection(
+                req, traces, timeout
+            )
+        sock = transport.get_extra_info("socket")
+        for option in self.socket_options:
+            sock.setsockopt(*option)
+        return proto