lusid-sdk 1.1.257__py3-none-any.whl → 2.0.438__py3-none-any.whl

lusid/utilities/api_client_factory.py

@@ -1,132 +0,0 @@
-import functools
-import importlib
-import inspect
-
-from lusid import ApiClient
-from lusid.utilities.api_client_builder import ApiClientBuilder
-from lusid.utilities.proxy_config import ProxyConfig
-from lusid.utilities.api_configuration import ApiConfiguration
-from lusid.utilities.lusid_retry import lusidretry
-
-
-class ApiClientFactory:
-    """
-    The ApiClientFactory is responsible for providing the ability to create any of the LUSID APIs using the provided
-    credentials. It will use the same ApiClient across all of the APIs.
-
-    """
-    def __init__(self, **kwargs):
-        """
-        Iniitalise an ApiClientFactory by passing the token, api_url and app_name, or by
-        passing in the api_secrets_filename
-
-        :param str token: Bearer token used to initialise the API
-        :param str api_secrets_filename: Name of secrets file (including full path)
-        :param str api_url: LUSID API url
-        :param str app_name: Application name (optional)
-        :param str certificate_filename: Name of the certificate file (.pem, .cer or .crt)
-        :param str proxy_url: The url of the proxy to use including the port e.g. http://myproxy.com:8888
-        :param str proxy_username: The username for the proxy to use
-        :param str proxy_password: The password for the proxy to use
-        :param str correlation_id: Correlation id for all calls made from the returned LUSID API instances
-        :param bool tcp_keep_alive: A flag for controlling if the API client uses TCP keep-alive probes
-        """
-
-        builder_kwargs = {}
-
-        if "token" in kwargs and str(kwargs["token"]) != "None":
-
-            # If there is a token use it along with the specified proxy details if specified
-            config = ApiConfiguration(
-                api_url=kwargs.get("api_url", None),
-                certificate_filename=kwargs.get("certificate_filename", None),
-                proxy_config=ProxyConfig(
-                    address=kwargs.get("proxy_url", None),
-                    username=kwargs.get("proxy_username", None),
-                    password=kwargs.get("proxy_password", None),
-                ) if kwargs.get("proxy_url", None) is not None else None,
-                app_name=kwargs.get("app_name", None)
-            )
-
-            builder_kwargs["api_configuration"] = config
-            builder_kwargs["token"] = kwargs["token"]
-
-        # Otherwise use a secrets file if it exists
-        builder_kwargs["api_secrets_filename"] = kwargs.get("api_secrets_filename", None)
-
-        # add the correlation id if specified
-        builder_kwargs["correlation_id"] = kwargs.get("correlation_id", None)
-
-        # add the id provider response handler if specified
-        builder_kwargs["id_provider_response_handler"] = kwargs.get("id_provider_response_handler", None)
-
-        builder_kwargs["tcp_keep_alive"] = kwargs.get("tcp_keep_alive", False)
-
-        # Call the client builder, this will result in using either a token, secrets file or environment variables
-        self.api_client = ApiClientBuilder.build(**builder_kwargs)
-
-    def build(self, metaclass):
-        """
-        :param type metaclass:  type of the LUSID API to create
-        :return: Initalised LUSID API for the type passed in
-        """
-
-        def get_attribute_impl(source_obj, name):
-            """
-            Implementation of __getattribute__ that adds a decorator that adds a call_info
-            argument to return additional call stats
-            """
-
-            attr = super(metaclass, source_obj).__getattribute__(name)
-
-            @functools.wraps(attr)
-            @lusidretry
-            def wrapper(*args, **kwargs):
-                def is_http_info_method(m):
-                    return inspect.ismethod(m) and m.__name__.endswith(
-                        "_with_http_info"
-                    )
-
-                if kwargs.get("call_info") is not None:
-                    callback = kwargs.pop("call_info")
-
-                    if not inspect.isfunction(callback):
-                        raise ValueError("call_info value must be a lambda")
-
-                    if is_http_info_method(attr):
-                        result = attr(*args, **kwargs)
-                    else:
-                        #   switch to the '_with_http_info' implementation
-                        func = getattr(source_obj, f"{name}_with_http_info")
-                        result = func(*args, **kwargs)
-
-                    # pass the http info to caller
-                    callback(result[2])
-
-                    # return the dto
-                    return result[0]
-
-                else:
-                    return attr(*args, **kwargs)
-
-            return wrapper if inspect.ismethod(attr) else attr
-
-        def init_impl(dest, src=None):
-            if type(dest) == type(src):
-                dest.__dict__ = src.__dict__
-            elif type(src) == ApiClient:
-                dest.api_client = src
-
-        module = importlib.import_module("lusid.api")
-        api_name = metaclass.__name__
-
-        if not api_name.endswith("Api") or not hasattr(module, api_name):
-            raise TypeError(f"unknown api: {api_name}")
-
-        # create an instance of the api
-        api_impl = getattr(module, api_name)(self.api_client)
-
-        setattr(metaclass, "__getattribute__", get_attribute_impl)
-        setattr(metaclass, "__init__", init_impl)
-
-        return api_impl

lusid/utilities/api_configuration.py

@@ -1,126 +0,0 @@
-import re
-
-
-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):
-        """
-        The configuration required to access LUSID, read more at https://support.finbourne.com/getting-started-with-apis-sdks
-
-        :param str token_url: The token URL of the identity provider
-        :param str api_url: The API URL for the LUSID client
-        :param str username: The username to use
-        :param str password: The password to use
-        :param str client_id: The client id to use
-        :param str client_secret: The client secret to use
-        :param str app_name: The name of the application calling LUSID
-        :param str certificate_filename: Name of the certificate file (.pem, .cer or .crt)
-        :param lusid.utilities.ProxyConfig proxy_config: The proxy configuration to use
-        """
-        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_config = proxy_config
-        self.__access_token = access_token
-
-    @property
-    def token_url(self):
-        return self.__token_url
-
-    @token_url.setter
-    def token_url(self, value):
-        def format_token_url(url: str) -> str:
-            """
-            Given an Okta issuer url (ie: https://lusid-testdomain.okta.com/oauth2/asd8f7a98sdf89a7ad), this function
-            will return a full token url (ie: https://lusid-testdomain.okta.com/oauth2/asd8f7a98sdf89a7ad/v1/token)
-            :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('^http(s)?:\/\/.*\.okta\.com\/oauth2\/.+', url, flags=re.IGNORECASE) is not None and
-                    # and it's missing the token suffix
-                    re.search('\/v\d+\/token$', url, flags=re.IGNORECASE) is None):
-                return url.rstrip('/') + '/v1/token'
-            return url
-
-        self.__token_url = format_token_url(value)
-
-    @property
-    def api_url(self):
-        return self.__api_url
-
-    @api_url.setter
-    def api_url(self, value):
-        self.__api_url = value
-
-    @property
-    def username(self):
-        return self.__username
-
-    @username.setter
-    def username(self, value):
-        self.__username = value
-
-    @property
-    def password(self):
-        return self.__password
-
-    @password.setter
-    def password(self, value):
-        self.__password = value
-
-    @property
-    def client_id(self):
-        return self.__client_id
-
-    @client_id.setter
-    def client_id(self, value):
-        self.__client_id = value
-
-    @property
-    def client_secret(self):
-        return self.__client_secret
-
-    @client_secret.setter
-    def client_secret(self, value):
-        self.__client_secret = value
-
-    @property
-    def app_name(self):
-        return self.__app_name
-
-    @app_name.setter
-    def app_name(self, value):
-        self.__app_name = value
-
-    @property
-    def certificate_filename(self):
-        return self.__certificate_filename
-
-    @certificate_filename.setter
-    def certificate_filename(self, value):
-        self.__certificate_filename = value
-
-    @property
-    def proxy_config(self):
-        return self.__proxy_config
-
-    @proxy_config.setter
-    def proxy_config(self, value):
-        self.__proxy_config = value
-
-    @property
-    def access_token(self):
-        return self.__access_token
-
-    @access_token.setter
-    def access_token(self, value):
-        self.__access_token = value
-

lusid/utilities/api_configuration_loader.py

@@ -1,87 +0,0 @@
-import json
-import os
-from pathlib import Path
-import logging
-
-from lusid.utilities.api_configuration import ApiConfiguration
-from lusid.utilities.proxy_config import ProxyConfig
-
-
-class ApiConfigurationLoader:
-    """
-    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.
-    """
-    @staticmethod
-    def load(api_secrets_filename=None):
-        """
-        :param str api_secrets_filename: The full path to the JSON file containing the API credentials and optional proxy details
-
-        :return: lusid.utilities.ApiConfiguration: The populated ApiConfiguration
-        """
-
-        # Get the config keys which contain the mapping between the ApiConfiguration attributes and the variable names
-        # in the secrets.json file and environment variables e.g. token_url is tokenUrl (secrets.json) and
-        # FBN_TOKEN_URL (env variable)
-        with open(Path(__file__).parent.joinpath('config_keys.json')) as json_file:
-            config_keys = json.load(json_file)
-
-        # The secrets file is a nested dictionary, set the names of the top level keys
-        api_config_key = "api"
-        proxy_config_key = "proxy"
-
-        def _load_config_from_secrets_file():
-
-            # If there is a secrets file specified and it exists get the details from it
-            if api_secrets_filename is not None and os.path.exists(api_secrets_filename) and os.path.isfile(api_secrets_filename):
-                with open(api_secrets_filename, "r") as secrets:
-                    config = json.load(secrets)
-
-            # If there is a secrets file specified and it does not exist log a warning to indicate that the specified file
-            # could not be found and create an empty config
-            elif api_secrets_filename is not None and (not os.path.exists(api_secrets_filename) or not os.path.isfile(api_secrets_filename)):
-                logging.debug(f"Provided secrets file of {api_secrets_filename} can not be found, please ensure you "
-                                 f"have correctly specified the full path to the file or don't provide a secrets file to use "
-                                 f"environment variables instead.")
-                config = {}
-            # If no secrets file is specified just create an empty config
-            else:
-                config = {}
-
-            return config
-
-        def _get_access_api_config():
-
-            config = _load_config_from_secrets_file()
-
-            # Populate the values for the api configuration preferring the secrets file over the environment variables
-            populated_api_config_values = {
-                key: config.get(api_config_key, {}).get(value["config"], os.getenv(value["env"], None))
-                for key, value in config_keys.items() if "proxy" not in key
-            }
-
-            return populated_api_config_values
-
-        def _get_proxy_api_config():
-
-            config = _load_config_from_secrets_file()
-
-            # Populate the values for the proxy preferring the secrets file over the environment variables
-            populated_proxy_values = {
-                key.replace("proxy_", ""): config.get(proxy_config_key, {}).get(value["config"], os.getenv(value["env"], None))
-                for key, value in config_keys.items() if "proxy" in key
-            }
-
-            return populated_proxy_values
-
-        populated_api_config_values = _get_access_api_config()
-        populated_proxy_values = _get_proxy_api_config()
-
-        # If the proxy address is missing ensure that no proxy is used in the ApiConfiguration
-        if populated_proxy_values.get("address", None) is None:
-            populated_api_config_values["proxy_config"] = None
-        # Otherwise create a ProxyConfig to use
-        else:
-            populated_api_config_values["proxy_config"] = ProxyConfig(**populated_proxy_values)
-        # Create and return the ApiConfiguration
-        return ApiConfiguration(**populated_api_config_values)

lusid/utilities/config_keys.json

@@ -1,50 +0,0 @@
-{
-  "token_url": {
-      "env": "FBN_TOKEN_URL",
-      "config": "tokenUrl"
-  },
-  "api_url": {
-      "env": "FBN_LUSID_API_URL",
-      "config": "apiUrl"
-  },
-  "username": {
-      "env": "FBN_USERNAME",
-      "config": "username"
-  },
-  "password": {
-      "env": "FBN_PASSWORD",
-      "config": "password"
-  },
-  "client_id": {
-      "env": "FBN_CLIENT_ID",
-      "config": "clientId"
-  },
-  "client_secret": {
-      "env": "FBN_CLIENT_SECRET",
-      "config": "clientSecret"
-  },
-  "app_name": {
-      "env": "FBN_APP_NAME",
-      "config": "applicationName"
-  },
-  "certificate_filename": {
-      "env": "FBN_CLIENT_CERTIFICATE",
-      "config": "clientCertificate"
-  },
-  "proxy_address": {
-      "env": "FBN_PROXY_ADDRESS",
-      "config": "address"
-  },
-  "proxy_username": {
-      "env": "FBN_PROXY_USERNAME",
-      "config": "username"
-  },
-  "proxy_password": {
-      "env": "FBN_PROXY_PASSWORD",
-      "config": "password"
-  },
-    "access_token": {
-      "env": "FBN_ACCESS_TOKEN",
-      "config": "accessToken"
-  }
-}

lusid/utilities/config_keys.py

@@ -1,13 +0,0 @@
-from pathlib import Path
-import json
-
-
-class ConfigKeys:
-    config_key_path = "config_keys.json"
-
-    @classmethod
-    def get(cls):
-        with open(Path(__file__).parent.joinpath(cls.config_key_path)) as json_file:
-            config_keys = json.load(json_file)
-
-        return config_keys

lusid/utilities/lusid_retry.py

@@ -1,47 +0,0 @@
-import functools
-from time import sleep
-
-from lusid import ApiException
-
-
-def lusidretry(fn):
-
-    @functools.wraps(fn)
-    def __retry(*args, **kwargs):
-
-        retries = kwargs.get("lusid_retries", 3)
-        if not isinstance(retries, int):
-            retries = 3
-
-        # remove the lusid_retries param from the kwargs
-        kwargs.pop("lusid_retries", None)
-
-        tries = 0
-        while tries < retries+1:
-            try:
-                return fn(*args, **kwargs)
-            except ApiException as ex:
-
-                tries += 1
-                retry_after = ex.headers.get("Retry-After")
-
-                # have done max number of retries
-                if tries == 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}")
-
-                    sleep(retry_after)
-
-                # no retry header
-                else:
-                    raise
-
-    return __retry

lusid_sdk-1.1.257.dist-info/METADATA

@@ -1,21 +0,0 @@
-Metadata-Version: 2.1
-Name: lusid-sdk
-Version: 1.1.257
-Summary: Python SDK for LUSID API
-Home-page: https://github.com/finbourne/lusid-sdk-python
-Author: FINBOURNE Technology
-Author-email: engineering@finbourne.com
-License: MIT
-Keywords: OpenAPI,FINBOURNE,LUSID,LUSID API
-Platform: UNKNOWN
-Requires-Dist: urllib3 (>=1.15)
-Requires-Dist: six (>=1.10)
-Requires-Dist: certifi (>=14.05.14)
-Requires-Dist: python-dateutil (>=2.5.3)
-Requires-Dist: urllib3 (>=1.15.1)
-Requires-Dist: requests (>=2.21.0)
-Requires-Dist: finbourne-sdk-utilities
-
-UNKNOWN
-
-