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

lusid/api_client.py

@@ -214,6 +214,8 @@ class ApiClient:
             url += "?" + url_query
 
         try:
+            # if returning http_data_only then we need to deserialise response.
+            _preload_content = True if _return_http_data_only else _preload_content
             # perform request and return response
             response_data = await self.request(
                 method, url,
@@ -260,8 +262,8 @@ class ApiClient:
         else:
             return ApiResponse(status_code = response_data.status,
                            data = return_data,
-                           headers = response_data.getheaders(),
-                           raw_data = response_data.data)
+                           headers = response_data.getheaders() if _preload_content else response_data.headers,
+                           raw_data = response_data.data if _preload_content else response_data)
 
     def sanitize_for_serialization(self, obj):
         """Builds a JSON POST object.
@@ -544,7 +546,7 @@ class ApiClient:
             if k in collection_formats:
                 collection_format = collection_formats[k]
                 if collection_format == 'multi':
-                    new_params.extend((k, value) for value in v)
+                    new_params.extend((k, quote(str(value))) for value in v)
                 else:
                     if collection_format == 'ssv':
                         delimiter = ' '

lusid/configuration.py

@@ -373,7 +373,7 @@ class Configuration:
         return "Python SDK Debug Report:\n"\
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
-               "Version of the API: 0.11.6001\n"\
+               "Version of the API: 0.11.6417\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)
 

lusid/extensions/__init__.py

@@ -1,15 +1,18 @@
-from lusid.extensions.api_client_builder import build_client
 from lusid.extensions.api_client_factory import SyncApiClientFactory, ApiClientFactory
 from lusid.extensions.configuration_loaders import (
     ConfigurationLoader,
     SecretsFileConfigurationLoader,
     EnvironmentVariablesConfigurationLoader,
     ArgsConfigurationLoader,
-    get_api_configuration,
 )
-from lusid.extensions.api_configuration import ApiConfiguration
-from lusid.extensions.retry import RetryingRestWrapper, RetryingRestWrapperAsync
-from lusid.extensions.proxy_config import ProxyConfig
-from lusid.extensions.refreshing_token import RefreshingToken
 from lusid.extensions.api_client import SyncApiClient
-from lusid.extensions.rest import RESTClientObject
+
+__all__ = [
+    "SyncApiClientFactory",
+    "ApiClientFactory",
+    "ConfigurationLoader",
+    "SecretsFileConfigurationLoader",
+    "EnvironmentVariablesConfigurationLoader",
+    "ArgsConfigurationLoader",
+    "SyncApiClient"
+]

lusid/extensions/api_client.py

@@ -213,6 +213,8 @@ class SyncApiClient:
             url += "?" + url_query
 
         try:
+            # if returning http_data_only then we need to deserialise response.
+            _preload_content = True if _return_http_data_only else _preload_content
             # perform request and return response
             response_data = self.request(
                 method, url,
@@ -543,7 +545,7 @@ class SyncApiClient:
             if k in collection_formats:
                 collection_format = collection_formats[k]
                 if collection_format == 'multi':
-                    new_params.extend((k, value) for value in v)
+                    new_params.extend((k, quote(str(value))) for value in v)
                 else:
                     if collection_format == 'ssv':
                         delimiter = ' '

lusid/extensions/api_client_factory.py

@@ -1,51 +1,117 @@
 from __future__ import annotations
+from lusid.api_client import ApiClient
+from lusid.extensions.retry import (
+    RetryingRestWrapper,
+    RetryingRestWrapperAsync
+)
+from lusid.extensions.api_client import SyncApiClient
 from lusid.extensions.configuration_loaders import (
     ConfigurationLoader,
     default_config_loaders,
+    get_api_configuration
+)
+from lusid.extensions.socket_keep_alive import keep_alive_socket_options
+from lusid.extensions.tcp_keep_alive_connector import (
+    TcpKeepAliveConnector,
+    TCPKeepAliveHTTPConnectionPool,
+    TCPKeepAliveHTTPSConnectionPool,
 )
-from lusid.extensions.api_client_builder import build_client
-from lusid.extensions.configuration_loaders import get_api_configuration
+from aiohttp import ClientSession
 import logging
-from typing import TypeVar, Type, Iterable
+from typing import Any, Callable, Optional, Tuple, TypeVar, Type, Iterable, Union
+import os
+from requests import Response
 
 logger = logging.getLogger(__name__)
 
 T = TypeVar("T")
 
 
+def set_additional_api_client_headers(
+    api_client: Union[ApiClient, SyncApiClient],
+    app_name: Optional[str] = None,
+    correlation_id: Optional[str] = None,
+) -> None:
+    """Sets additional headers for additional debugging info in LUSID
+
+    Parameters
+    ----------
+    api_client : Union[ApiClient, SyncApiClient]
+        api client to set headers on
+    app_name : Optional[str], optional
+        name of the application in LUSID, by default None
+    correlation_id : Optional[str], optional
+        correlation id to track requests in LUSID, by default None
+    """
+    try:
+        # set the application name if specified
+        if app_name is not None:
+            api_client.set_default_header("X-LUSID-Application", app_name)
+
+        # set a correlation id for all requests initiated with this ApiClient
+        corr_id = correlation_id or os.getenv("FBN_CORRELATION_ID")
+        if corr_id is not None:
+            api_client.set_default_header("CorrelationId", corr_id)
+    except AttributeError:
+        logger.exception("api_client must be either an ApiClient or a SyncApiClient")
+        raise
+
+
 class SyncApiClientFactory:
     def __init__(
         self,
         config_loaders: Iterable[ConfigurationLoader] = default_config_loaders,
-        id_provider_response_handler=None,
-        tcp_keep_alive=None,
-        correlation_id=None,
-        app_name=None
+        id_provider_response_handler: Callable[[Response], None] = None,
+        tcp_keep_alive: bool = True,
+        socket_options: Optional[
+            Union[Tuple[Any, Any, Any], Tuple[Any, Any, None, int]]
+        ] = keep_alive_socket_options(),
+        correlation_id: Optional[str] = None,
+        app_name: Optional[str] = None,
     ):
-        """Create an ApiClientFactory which can build api objects with a configured ApiClient object
+        """Create an ApiClientFactory which can build
+        api objects with a configured ApiClient object
 
         Parameters
         ----------
         config_loaders : Iterable[ConfigurationLoader], optional
-            An Iterable of ConfigurationLoaders we can load configuration from.
-            Config settings are updated by each loader (last write wins), by default default_config_loaders
-        id_provider_response_handler : _type_, optional
-             A function that is called when a response is received from the token_url., by default None
-        tcp_keep_alive : _type_, optional
-            Should ApiClient be configured to send tcp keep alives., by default None
-        correlation_id : _type_, optional
-            A correlation ID that can be sent with each request., by default None
-        app_name : _type_, optional
-            The name of the application in LUSID., by default None
+        An Iterable of ConfigurationLoaders we can load configuration from.
+        Config settings are updated by each loader (last write wins),
+        by default default_config_loaders,
+        by default default_config_loaders
+        id_provider_response_handler : Callable[[Response], None], optional
+        A function that is called when a response is received from the token_url,
+        by default None
+        tcp_keep_alive : bool, optional
+        Should ApiClient be configured to send tcp keep alives, by default True
+        socket_options : Optional[ Union[Tuple[Any, Any, Any], Tuple[Any, Any, None, int]] ], optional
+        Set of socket options that should be applied to each connection, 
+        by default keep_alive_socket_options
+        correlation_id : Optional[str], optional
+        A correlation ID that can be sent with each request, by default None
+        app_name : Optional[str], optional
+        The name of the application in LUSID, by default None
         """
         api_config = get_api_configuration(config_loaders=config_loaders)
-        self.__api_client = build_client(
-            api_config,
-            build_async_client=False,
-            id_provider_response_handler=id_provider_response_handler,
+        api_client_config = api_config.build_api_client_config(
             tcp_keep_alive=tcp_keep_alive,
-            correlation_id=correlation_id,
-            app_name=app_name
+            socket_options=socket_options,
+            id_provider_response_handler=id_provider_response_handler
+        )
+        self.__api_client = SyncApiClient(
+            configuration=api_client_config,
+        )
+
+        rest_client_wrapper = RetryingRestWrapper
+        rc = self.__api_client.rest_client
+        if tcp_keep_alive:
+            rc.pool_manager.pool_classes_by_scheme = {"http": TCPKeepAliveHTTPConnectionPool, "https": TCPKeepAliveHTTPSConnectionPool}
+
+        wrapped_rest_client = rest_client_wrapper(rc)
+        self.__api_client.rest_client = wrapped_rest_client
+
+        set_additional_api_client_headers(
+            self.__api_client, app_name=app_name, correlation_id=correlation_id
         )
 
     def __enter__(self):
@@ -79,35 +145,80 @@ class ApiClientFactory:
     def __init__(
         self,
         config_loaders: Iterable[ConfigurationLoader] = default_config_loaders,
-        id_provider_response_handler=None,
-        tcp_keep_alive=None,
-        correlation_id=None,
-        app_name=None
+        id_provider_response_handler: Callable[[Response], None] = None,
+        tcp_keep_alive: bool = True,
+        socket_options: Optional[
+            Union[Tuple[Any, Any, Any], Tuple[Any, Any, None, int]]
+        ] = keep_alive_socket_options(),
+        correlation_id: Optional[str] = None,
+        app_name: Optional[str] = None,
+        client_session: Optional[ClientSession] = None,
+        trace_configs: Optional[List[TraceConfig]] = None
     ):
-        """Create an ApiClientFactory which can build api objects with a configured ApiClient object
+        """Create an ApiClientFactory which can build api 
+        objects with a configured ApiClient object
 
         Parameters
         ----------
         config_loaders : Iterable[ConfigurationLoader], optional
-            An Iterable of ConfigurationLoaders we can load configuration from.
-            Config settings are updated by each loader (last write wins), by default default_config_loaders
-        id_provider_response_handler : _type_, optional
-             A function that is called when a response is received from the token_url., by default None
-        tcp_keep_alive : _type_, optional
-            Should ApiClient be configured to send tcp keep alives., by default None
-        correlation_id : _type_, optional
-            A correlation ID that can be sent with each request., by default None
-        app_name : _type_, optional
-            The name of the application in LUSID., by default None
+        An Iterable of ConfigurationLoaders we can load configuration from.
+        Config settings are updated by each loader (last write wins), 
+        by default default_config_loaders
+        id_provider_response_handler : Callable[[Response], None], optional
+        A function that is called when a response is received from the token_url,
+        by default None
+        tcp_keep_alive : bool, optional
+        Should ApiClient be configured to send tcp keep alives, by default True
+        socket_options : Optional[ Union[Tuple[Any, Any, Any], Tuple[Any, Any, None, int]] ], optional
+        Set of socket options that should be applied to each connection,
+        by default keep_alive_socket_options
+        correlation_id : Optional[str], optional
+        A correlation ID that can be sent with each request, by default None
+        app_name : Optional[str], optional
+        The name of the application in LUSID, by default None
+        client_session : Optional[ClientSession], optional
+        An aiohttp.ClientSession, pass this to re-use 
+        connections across different ApiFactories,
+        by default None
+        trace_configs: Optional[List[TraceConfig]], optional
+        A list of aiohttp TraceConfigs, used to set up request tracing.
+        by default None
         """
         api_config = get_api_configuration(config_loaders=config_loaders)
-        self.__api_client = build_client(
-            api_config,
-            build_async_client=True,
-            id_provider_response_handler=id_provider_response_handler,
+        api_client_config = api_config.build_api_client_config(
             tcp_keep_alive=tcp_keep_alive,
-            correlation_id=correlation_id,
-            app_name=app_name
+            socket_options=socket_options,
+            id_provider_response_handler=id_provider_response_handler
+        )
+        self.__api_client = ApiClient(
+            configuration=api_client_config,
+        )
+        rc = self.__api_client.rest_client
+        try:
+            if client_session is not None:
+                connector = client_session.connector
+                # by default take explicitly passed trace_config param
+                # otherwise copy from session.
+                trace_configs = trace_configs or client_session.trace_configs
+            else:
+                connector = rc.pool_manager.connector
+            if tcp_keep_alive:
+                connector = TcpKeepAliveConnector(connector=connector, socket_options=socket_options)
+            # dereference connector so existing session closes correctly
+            rc.pool_manager._connector = None
+            rc.pool_manager = ClientSession(
+                connector=connector,
+                trust_env=True,
+                trace_configs=trace_configs
+            )
+        except AttributeError:
+            logger.exception("client_session must be an aiohttp.ClientSession"
+                             " object with an initialised TCP Connector")
+        rest_client_wrapper = RetryingRestWrapperAsync
+        wrapped_rest_client = rest_client_wrapper(rc)
+        self.__api_client.rest_client = wrapped_rest_client
+        set_additional_api_client_headers(
+            self.__api_client, app_name=app_name, correlation_id=correlation_id
         )
 
     async def __aenter__(self):

lusid/extensions/api_configuration.py

@@ -1,10 +1,28 @@
 import re
+import logging
+from typing import Optional, Union, Tuple, Any, Callable
+from lusid.configuration import Configuration
+from lusid.extensions.refreshing_token import RefreshingToken
+from lusid.extensions.socket_keep_alive import keep_alive_socket_options
+from lusid.extensions.proxy_config import ProxyConfig
+from requests import Response
+logger = logging.getLogger(__name__)
 
 
 class ApiConfiguration:
-
-    def __init__(self, token_url=None, api_url=None, username=None, password=None, client_id=None, client_secret=None,
-                 app_name=None, certificate_filename=None, proxy_config=None, access_token=None):
+    def __init__(
+        self,
+        token_url=None,
+        api_url=None,
+        username=None,
+        password=None,
+        client_id=None,
+        client_secret=None,
+        app_name=None,
+        certificate_filename=None,
+        proxy_config:Optional[ProxyConfig]=None,
+        access_token=None,
+    ):
         """
         The configuration required to access LUSID, read more at https://support.finbourne.com/getting-started-with-apis-sdks
 
@@ -42,12 +60,19 @@ class ApiConfiguration:
             :param url: The url to format
             :return: An Okta token url (if the input is an Okta issuer url). The original url otherwise.
             """
-            if (url is not None and
-                    # and it's an Okta oauth2 URL
-                    re.search(r'^http(s)?:\/\/.*\.okta\.com\/oauth2\/.+', url, flags=re.IGNORECASE) is not None and
-                    # and it's missing the token suffix
-                    re.search(r'\/v\d+\/token$', url, flags=re.IGNORECASE) is None):
-                return url.rstrip('/') + '/v1/token'
+            if (
+                url is not None
+                and
+                # and it's an Okta oauth2 URL
+                re.search(
+                    r"^http(s)?:\/\/.*\.okta\.com\/oauth2\/.+", url, flags=re.IGNORECASE
+                )
+                is not None
+                and
+                # and it's missing the token suffix
+                re.search(r"\/v\d+\/token$", url, flags=re.IGNORECASE) is None
+            ):
+                return url.rstrip("/") + "/v1/token"
             return url
 
         self.__token_url = format_token_url(value)
@@ -116,10 +141,94 @@ class ApiConfiguration:
     def proxy_config(self, value):
         self.__proxy_config = value
 
-    @property
-    def access_token(self):
-        return self.__access_token
+    def __setattr__(self, name, value):
+        if name == "access_token":
+            self.__access_token = value
+        super(ApiConfiguration, self).__setattr__(name, value)
+
+    def get_access_token(
+        self, id_provider_response_handler: Callable[[Response], None] = None
+    ) -> Union[str, RefreshingToken]:
+        """Gets either the set personal access token, or a RefreshingToken using OIDC parameters
 
-    @access_token.setter
-    def access_token(self, value):
-        self.__access_token = value
+        Returns
+        -------
+        Union[str, RefreshingToken]
+            Token that can be used to authenticate to LUSID
+
+        """
+        try:
+            if self.__access_token is not None:
+                return self.__access_token
+            logger.debug(
+                "Access token not provided, \
+                    will attempt to set up client using OIDC parameters"
+            )
+            return RefreshingToken(
+                api_configuration=self,
+                id_provider_response_handler=id_provider_response_handler,
+            )
+        except AttributeError:
+            logger.exception(
+                "Could not retrieve access token - "
+                "ensure api_config is an ApiConfiguration object"
+            )
+            raise
+        except ValueError:
+            logger.exception(
+                "Could not retrieve access token - "
+                "ensure fields required to authenticate are set"
+            )
+            raise
+
+    def build_api_client_config(
+        self,
+        tcp_keep_alive: bool = True,
+        socket_options: Optional[
+            Union[Tuple[Any, Any, Any], Tuple[Any, Any, None, int]]
+        ] = keep_alive_socket_options(),
+        id_provider_response_handler: Optional[Callable[[Response], None]] = None,
+    ) -> Configuration:
+        """Builds lusid.Configuration for initialising an api client.
+
+        Parameters
+        ----------
+        tcp_keep_alive : bool, optional
+            Should socket options for tcp keep alive pings be set, by default True
+        socket_options : Optional[ Union[Tuple[Any, Any, Any], Tuple[Any, Any, None, int]] ], optional
+            A set of custom options to configure on connections, by default keep_alive_socket_options()
+        id_provider_response_handler : Optional[Callable[[Response], None]], optional
+            A function to run on response from the identity provider, by default None
+
+        Returns
+        -------
+        Configuration
+            config which can be used to initialise an api client
+        """
+        access_token = self.get_access_token(
+            id_provider_response_handler=id_provider_response_handler
+        )
+        try:
+            if self.api_url is None:
+                logger.error("Api Url must have a value")
+                raise ValueError("Api Url must have a value")
+            if access_token is None:
+                logger.error("Access token must have a value")
+                raise ValueError("Access token must have a value")
+            config = Configuration(
+                access_token=access_token,
+                host=self.api_url,
+                ssl_ca_cert=self.certificate_filename,
+            )
+            if tcp_keep_alive:
+                config.socket_options = socket_options or keep_alive_socket_options()
+            # Set the proxy for lusid if needed
+            if self.proxy_config is not None:
+                config.proxy = self.proxy_config.address
+                config.proxy_headers = self.proxy_config.headers
+            return config
+        except (AttributeError, ValueError):
+            logger.exception(
+                "Unable to build api client, required configuration not provided"
+            )
+            raise

lusid/extensions/configuration_loaders.py

@@ -24,7 +24,7 @@ ENVIRONMENT_CONFIG_KEYS = {
 
 SECRETS_FILE_CONFIG_KEYS = {
     "token_url": "tokenUrl",
-    "api_url": "apiUrl",
+    "api_url": "lusidUrl",
     "username": "username",
     "password": "password",
     "client_id": "clientId",
@@ -191,9 +191,7 @@ def get_api_configuration(config_loaders: Iterable[ConfigurationLoader]) -> ApiC
     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/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/socket_keep_alive.py

@@ -5,6 +5,15 @@ from urllib3.connection import HTTPConnection
 
 __logger__ = logging.getLogger(__name__)
 
+# 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
+
 
 def keep_alive_socket_options() -> Sequence:
     """Returns default socket options for all platforms for
@@ -15,15 +24,6 @@ def keep_alive_socket_options() -> Sequence:
     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 + [
@@ -35,18 +35,17 @@ def keep_alive_socket_options() -> Sequence:
     except AttributeError:
         pass
     try:
-        # other windows runtimes
+        # darwin
         return HTTPConnection.default_socket_options + [
-            socket.SIO_KEEPALIVE_VALS,
-            (1, TCP_KEEP_IDLE * 1000, TCP_KEEPALIVE_INTERVAL * 1000),
+            (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
+            (socket.IPPROTO_TCP, TCP_KEEPALIVE, TCP_KEEPALIVE_INTERVAL),
         ]
     except AttributeError:
         pass
     try:
-        # darwin
+        # windows
         return HTTPConnection.default_socket_options + [
-            (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
-            (socket.IPPROTO_TCP, TCP_KEEPALIVE, TCP_KEEPALIVE_INTERVAL),
+            (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
         ]
     except AttributeError:
         __logger__.exception("Unable to set TCP Keep-alive socket options")