sap-ai-sdk-core 2.9.9__py3-none-any.whl → 3.0.8__py3-none-any.whl

ai_core_sdk/ai_core_v2_client.py

@@ -0,0 +1,157 @@
+from ai_core_sdk.helpers.logging import get_logger
+from typing import Callable
+import os
+
+from ai_core_sdk.helpers import is_within_aicore
+from ai_core_sdk.resource_clients import (
+    AIAPIV2Client,
+    ArtifactClient,
+    ConfigurationClient,
+    DeploymentClient,
+    ExecutableClient,
+    ExecutionClient,
+    RestClient,
+    ScenarioClient,
+    ResourceGroupsClient,
+    MetaClient,
+    ModelClient,
+)
+from ai_core_sdk.resource_clients.applications_client import ApplicationsClient
+from ai_core_sdk.resource_clients.docker_registry_secrets_client import DockerRegistrySecretsClient
+from ai_core_sdk.resource_clients.internal_rest_client import InternalRestClient
+from ai_core_sdk.resource_clients.metrics_client import MetricsCoreClient
+from ai_core_sdk.resource_clients.object_store_secrets_client import ObjectStoreSecretsClient
+from ai_core_sdk.resource_clients.kpi_client import KpiClient
+from ai_core_sdk.resource_clients.repositories_client import RepositoriesClient
+from ai_core_sdk.resource_clients.secrets_client import SecretsClient
+from ai_core_sdk.helpers.constants import Timeouts
+from ai_core_sdk.credentials import fetch_credentials
+
+
+class AICoreV2Client:
+    """The AICoreV2Client is the class implemented to interact with the AI Core endpoints. The user can use its
+    attributes corresponding to the resources, for interacting with endpoints related to that resource. (i.e.,
+    aicoreclient.scenario)
+
+    :param base_url: Base URL of the AI Core. Should include the base path as well. (i.e., "<base_url>/lm/scenarios"
+        should work)
+    :type base_url: str
+    :param auth_url: URL of the authorization endpoint. Should be the full URL (including /oauth/token), defaults to
+        None
+    :type auth_url: str, optional
+    :param client_id: client id to be used for authorization, defaults to None
+    :type client_id: str, optional
+    :param client_secret: client secret to be used for authorization, defaults to None
+    :type client_secret: str, optional
+    :param cert_str: certificate file content, needs to be provided alongside the key_str parameter, defaults to None
+    :type cert_str: str, optional
+    :param key_str: key file content, needs to be provided alongside the cert_str parameter, defaults to None
+    :type key_str: str, optional
+    :param cert_file_path: path to the certificate file, needs to be provided alongside the key_file_path parameter,
+        defaults to None
+    :type cert_file_path: str, optional
+    :param key_file_path: path to the key file, needs to be provided alongside the cert_file_path parameter,
+        defaults to None
+    :type key_file_path: str, optional
+    :param token_creator: the function which returns the Bearer token, when called. Either this, or
+        auth_url & client_id & client_secret should be specified, defaults to None
+    :type token_creator: Callable[[], str], optional
+    :param resource_group: The default resource group which will be used while sending the requests to the server. If
+        not set, the resource_group should be specified with every request to the server, defaults to None
+    :type resource_group: str, optional
+    :param read_timeout: Read timeout for requests in seconds, defaults to 60s
+    :type read_timeout: int
+    :param connect_timeout: Connect timeout for requests in seconds, defaults to 60s
+    :type connect_timeout: int
+    :param num_request_retries: Number of retries for failing requests with http status code 429, 500, 502, 503 or 504,
+        defaults to 60s
+    :type num_request_retries: int
+    """
+    logger = get_logger()
+
+    def __init__(self, base_url: str, auth_url: str = None, client_id: str = None, client_secret: str = None,
+                 cert_str: str = None, key_str: str = None, cert_file_path: str = None, key_file_path: str = None,
+                 token_creator: Callable[[], str] = None, resource_group: str = None,
+                 read_timeout=Timeouts.READ_TIMEOUT.value, connect_timeout=Timeouts.CONNECT_TIMEOUT.value,
+                 num_request_retries=Timeouts.NUM_REQUEST_RETRIES.value):
+        self.base_url: str = base_url
+        ai_api_base_url = f'{base_url}/lm'
+        token_creator = AIAPIV2Client._create_token_creator_if_does_not_exist(
+            token_creator=token_creator, auth_url=auth_url, client_id=client_id, client_secret=client_secret,
+            cert_str=cert_str, key_str=key_str, cert_file_path=cert_file_path, key_file_path=key_file_path)
+
+        client_type = "AI Core Python SDK"
+
+        ai_api_v2_client = AIAPIV2Client(base_url=ai_api_base_url, token_creator=token_creator,
+                                         resource_group=resource_group, read_timeout=read_timeout,
+                                         connect_timeout=connect_timeout, num_request_retries=num_request_retries,
+                                         client_type=client_type)
+
+        self.rest_client: RestClient = RestClient(base_url=base_url, get_token=token_creator,
+                                                  resource_group=resource_group, read_timeout=read_timeout,
+                                                  connect_timeout=connect_timeout,
+                                                  num_request_retries=num_request_retries,
+                                                  client_type=client_type)
+        self.artifact: ArtifactClient = ai_api_v2_client.artifact
+        self.configuration: ConfigurationClient = ai_api_v2_client.configuration
+        self.deployment: DeploymentClient = ai_api_v2_client.deployment
+        self.executable: ExecutableClient = ai_api_v2_client.executable
+        self.execution: ExecutionClient = ai_api_v2_client.execution
+        self.resource_groups: ResourceGroupsClient = ai_api_v2_client.resource_groups
+        self.meta: MetaClient = ai_api_v2_client.meta
+        self.model: ModelClient = ai_api_v2_client.model
+        # If the environment variables have AICORE_EXECUTION_ID and AICORE_TRACKING_ENDPOINT,
+        # it indicates the sdk is used within the training pod
+        # Initiating an internal rest client if within the training pod
+        # Else initiating the rest client from ai_api_v2_client
+        if is_within_aicore():
+            self.metrics: MetricsCoreClient = MetricsCoreClient(
+                rest_client=InternalRestClient(
+                    client_type=client_type,
+                    read_timeout=read_timeout,
+                    connect_timeout=connect_timeout,
+                    num_request_retries=num_request_retries,
+                ),
+                execution_id=os.getenv("AICORE_EXECUTION_ID"),
+            )
+        else:
+            self.metrics: MetricsCoreClient = MetricsCoreClient(rest_client=ai_api_v2_client.rest_client)
+        self.scenario: ScenarioClient = ai_api_v2_client.scenario
+        self.docker_registry_secrets: DockerRegistrySecretsClient = DockerRegistrySecretsClient(
+            rest_client=self.rest_client)
+        self.applications: ApplicationsClient = ApplicationsClient(rest_client=self.rest_client)
+        self.object_store_secrets: ObjectStoreSecretsClient = ObjectStoreSecretsClient(rest_client=self.rest_client)
+        self.secrets: SecretsClient = SecretsClient(rest_client=self.rest_client)
+        self.kpis: KpiClient = KpiClient(rest_client=self.rest_client)
+        self.repositories: RepositoriesClient = RepositoriesClient(rest_client=self.rest_client)
+
+    @staticmethod
+    def from_env(profile_name: str = None,
+                 **kwargs):
+        """Alternative way to create an AICoreV2Client object.
+        Parameters for base_url, auth_url, client_id, client_secret, x.509 credentials (either as file path or string)
+        and resource_group can be passed as keyword or are pulled from environment variables.
+        It is also possible to use a profile, which is a json file in the config directory. The profile name can be
+        passed as keyword or is pulled from the environment variable AICORE_PROFILE. If no profile is specified,
+        the default profile is used.
+        A specific path to a config, that should be used, can be set via the environment variable AICORE_CONFIG.
+        The hierarchy of precedence is:
+        1. keyword argument
+        2. environment variable
+        3. configuration file
+        4. value from VCAP_SERVICES environment variable, if exists
+
+        :param profile_name: name of the profile to use, defaults to None. If None is passed, the profile is read from
+            the environment variable AICORE_PROFILE. If this is not set, the default profile is used.
+            The default profile is read from $AICORE_HOME/config.json.
+        :type profile_name: optional, str
+        **kwargs: check the parameters of the class constructor
+        """
+        env_credentials = fetch_credentials(profile=profile_name, **kwargs)
+
+        # if cert_url is present in the fetched credentials, rename it to auth_url
+        if 'cert_url' in env_credentials.keys():
+            env_credentials['auth_url'] = env_credentials.pop('cert_url')
+
+        kwargs.update(env_credentials)
+        return AICoreV2Client(**kwargs)

ai_core_sdk/cli.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+from typing import Optional
+import json
+import pathlib
+from urllib.parse import urlparse
+
+from ai_core_sdk.credentials import CREDENTIAL_VALUES, get_nested_value
+from ai_core_sdk.helpers import get_home
+from ai_core_sdk.helpers.constants import AI_CORE_PREFIX
+
+import click
+
+# Constants
+MAX_TRIES = 5
+OAUTH_TOKEN_SUFFIX = '/oauth/token'
+API_V2_SUFFIX = '/v2'
+DEFAULT_CONFIG = 'config.json'
+DEFAULT_RESOURCE_GROUP = 'default'
+DEFAULT_PROFILE = 'default'
+
+# Utility Functions
+def create_config(**kwargs):
+    return {f'{AI_CORE_PREFIX}_{k}'.upper(): v for k, v in kwargs.items() if v is not None}
+
+def is_valid_url(url, path_forbidden=True):
+    try:
+        result = urlparse(url)
+        return all([result.scheme, result.netloc, not result.path if path_forbidden else True])
+    except ValueError:
+        return False
+
+def prompt_for_input(prompt_text, is_url=False, path_forbidden=True):
+    url = None
+    for _ in range(MAX_TRIES):
+        user_input = click.prompt(prompt_text, type=str).rstrip('/')
+        if is_url and not is_valid_url(user_input, path_forbidden):
+            click.echo('Input is not a valid URL.')
+            if path_forbidden:
+                click.echo('Enter URL without any additional path or trailing slash.')
+        else:
+            url = user_input
+            break
+
+    if url is None:
+        raise ValueError('Max tries reached!')
+    return url
+
+# CLI Functions
+@click.group()
+@click.option('-p', '--profile', default=DEFAULT_PROFILE, type=str)
+@click.pass_context
+def cli(ctx, profile):
+    """CLI group for the AI Core SDK"""
+    ctx.ensure_object(dict)
+    ctx.obj['profile'] = profile
+
+
+def load_service_key(service_key_json: str):
+    with pathlib.Path(service_key_json).open() as stream:
+        service_key = json.load(stream)
+    kwargs = {}
+    for value in CREDENTIAL_VALUES:
+        # In VCAP the service_key is nested under credentials
+        # We can reuse the vcap_name from the CREDENTIAL_VALUES
+        # when parsing the service_key
+        # skip if vcap_key not defined
+        if not value.vcap_key:
+            continue
+        try:
+            kwargs[value.name] = get_nested_value(service_key, value.vcap_key[1:])
+        except KeyError:
+            kwargs[value.name] = None
+    return kwargs
+
+def get_auth_url(auth_url: Optional[str]=None):
+    auth_url = auth_url or prompt_for_input('Please enter the authorization URL', is_url=True, path_forbidden=False)
+    if auth_url.endswith(OAUTH_TOKEN_SUFFIX):
+        return auth_url
+    else:
+        return auth_url + OAUTH_TOKEN_SUFFIX
+
+def get_base_url(base_url: Optional[str]=None):
+    base_url = base_url or prompt_for_input('Please enter the base API URL', is_url=True, path_forbidden=False)
+    if base_url.endswith(API_V2_SUFFIX):
+        return base_url
+    else:
+        return base_url + API_V2_SUFFIX
+
+
+def get_str_value(msg: str, value: Optional[str]=None):
+    return value or click.prompt(msg, type=str)
+
+def confirm_resource_group(resource_group: Optional[str]=None):
+    if resource_group is None:
+        resource_group = click.prompt('Please confirm or enter the AICore resource group', default=DEFAULT_RESOURCE_GROUP, type=str)
+    return resource_group
+
+def get_profile_config_path(profile: str):
+    profile = profile if profile != DEFAULT_PROFILE and profile is not None else None
+    home = pathlib.Path(get_home())
+    home.mkdir(parents=True, exist_ok=True)
+    config_path = home / (DEFAULT_CONFIG if profile is None else f'config_{profile.lower()}.json')
+    if profile is not None:
+        click.echo(f'Remember to set `{AI_CORE_PREFIX}_PROFILE={profile.lower()}` to use your profile.')
+    return config_path
+
+
+def create_config_file(config_path: pathlib.Path, auth_url: str, client_id: str, client_secret: str,
+                       cert_file_path: pathlib.Path, key_file_path: pathlib.Path, base_url: str, resource_group: str):
+    config = create_config(auth_url=auth_url, client_id=client_id, client_secret=client_secret,
+                           cert_file_path=cert_file_path, key_file_path=key_file_path, base_url=base_url,
+                           resource_group=resource_group)
+    if config_path.exists() and not click.confirm(f'A config file {config_path} already exists. Do you want to replace it?'):
+        exit()
+    click.echo(f'Creating new config {config_path}')
+    with config_path.open('w') as stream:
+        json.dump(config, stream, indent=4)
+
+
+@cli.command()
+@click.option('-a', '--auth-url', default=None, type=str)
+@click.option('-s', '--client-secret', default=None, type=str)
+@click.option('-i', '--client-id', default=None, type=str)
+@click.option('-cf', '--cert-file-path', default=None, type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@click.option('-kf', '--key-file-path', default=None, type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@click.option('-u', '--base-url', default=None, type=str)
+@click.option('-g', '--resource-group', default=None, type=str)
+@click.option('-k', '--service-key-json', default=None, type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@click.pass_context
+def configure(ctx, auth_url, client_secret, client_id, cert_file_path, key_file_path, base_url, resource_group,
+              service_key_json):
+    profile = ctx.obj['profile']
+    if service_key_json:
+        service_key_json = load_service_key(service_key_json)
+    else:
+        service_key_json = {}
+
+    base_url = get_base_url(service_key_json.get('base_url', base_url))
+    auth_url = get_auth_url(service_key_json.get('auth_url', auth_url))
+    cert_url = service_key_json.get('cert_url', None)
+    if cert_url:
+        auth_url = get_auth_url(cert_url)
+    client_id = get_str_value('Please enter the client ID', service_key_json.get('client_id', client_id))
+
+    client_secret = service_key_json.get('client_secret', client_secret)
+    cert_file_path = service_key_json.get('cert_file_path', cert_file_path)
+    key_file_path = service_key_json.get('key_file_path', key_file_path)
+
+    if not (client_secret is not None or (key_file_path is not None or cert_file_path is not None)):
+        client_secret = get_str_value(
+            'Please enter the client secret (skip, if you\'re going to provide X.509 credentials',
+            service_key_json.get('client_secret', client_secret))
+        cert_file_path = get_str_value('Please enter path to the X.509 certificate file',
+                                       service_key_json.get('cert_file_path', cert_file_path))
+        key_file_path = get_str_value('Please enter path to the X.509 key file',
+                                      service_key_json.get('key_file_path', key_file_path))
+    resource_group = confirm_resource_group(resource_group)
+    create_config_file(
+        config_path=get_profile_config_path(profile),
+        auth_url=auth_url,
+        client_id=client_id,
+        client_secret=client_secret,
+        cert_file_path=cert_file_path,
+        key_file_path=key_file_path,
+        base_url=base_url,
+        resource_group=resource_group
+    )
+
+
+
+if __name__ == "__main__":
+    cli() #pylint: disable = no-value-for-parameter

ai_core_sdk/credentials.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Final, List, Optional, Callable, Union, Tuple
+import json
+import os
+import pathlib
+
+from dataclasses import dataclass
+
+from ai_core_sdk.helpers import get_home
+from ai_core_sdk.helpers.constants import (AI_CORE_PREFIX, AUTH_ENDPOINT_SUFFIX, CONFIG_FILE_ENV_VAR, PROFILE_ENV_VAR,
+                                           VCAP_AICORE_SERVICE_NAME, VCAP_SERVICES_ENV_VAR)
+from ai_core_sdk.helpers.logging import get_logger
+
+logger = get_logger()
+
+
+def get_nested_value(data_dict, keys: List[str]):
+    """
+    Retrieve a nested value from a dictionary using a list of strings.
+
+    :param data_dict: The dictionary to search.
+    :param keys: A list of strings representing nested keys.
+    :return: The value associated with the nested keys, or None if not found.
+    """
+    current_value = data_dict
+    for key in keys:
+        current_value = current_value[key]
+    return current_value
+
+
+@dataclass
+class VCAPEnvironment:
+    services: List[Service]
+
+    @classmethod
+    def from_env(cls, env_var: Optional[str] = None):
+        env_var = env_var or VCAP_SERVICES_ENV_VAR
+        env = json.loads(os.environ.get(env_var, '{}'))
+        return cls.from_dict(env)
+
+    @classmethod
+    def from_dict(cls, env: Dict[str, Any]):
+        services = [Service(service) for services in env.values() for service in services]
+        return cls(services=services)
+
+    def __getitem__(self, name) -> Service:
+        return self.get_service(name, exactly_one=True)
+
+    def get_service(self, label, exactly_one: bool = True) -> Service:
+        services = [s for s in self.services if s.label == label]
+        if exactly_one:
+            if len(services) == 0:
+                raise KeyError(f"No service found with label '{label}'.")
+            return services[0]
+        else:
+            return services
+
+    def get_service_by_name(self, name, exactly_one: bool = True) -> Service:
+        services = [s for s in self.services if s.name == name]
+        if exactly_one:
+            if len(services) == 0:
+                raise KeyError(f"No service found with name '{name}'.")
+            return services[0]
+        else:
+            return services
+
+
+NoDefault = object()
+
+
+class Service:
+
+    def __init__(self, env: Dict[str, Any]):
+        self._env = env
+
+    @property
+    def label(self) -> Optional[str]:
+        return self._env.get('label')
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._env.get('name')
+
+    def __getitem__(self, key):
+        return self.get(key)
+
+    def get(self, key, default=NoDefault):
+        if isinstance(key, str):
+            key_splitted = key.split('.')
+        else:
+            key_splitted = key
+        try:
+            return get_nested_value(self._env, key_splitted) or default
+        except KeyError:
+            if default is NoDefault:
+                raise KeyError(f"Key '{key}' not found in service '{self.name}'.")
+            return default
+
+
+@dataclass
+class CredentialsValue:
+    name: str
+    vcap_key: Optional[Tuple[str, ...]] = None
+    default: Optional[str] = None
+    transform_fn: Optional[Callable] = None
+
+
+CREDENTIAL_VALUES: Final[List[CredentialsValue]] = [
+    CredentialsValue(name='client_id', vcap_key=('credentials', 'clientid')),
+    CredentialsValue(name='client_secret', vcap_key=('credentials', 'clientsecret')),
+    CredentialsValue(name='auth_url',
+                     vcap_key=('credentials', 'url'),
+                     transform_fn=lambda url: url.rstrip('/') +
+                                              ('' if url.endswith(AUTH_ENDPOINT_SUFFIX) else AUTH_ENDPOINT_SUFFIX)),
+    CredentialsValue(name='base_url',
+                     vcap_key=('credentials', 'serviceurls', 'AI_API_URL'),
+                     transform_fn=lambda url: url.rstrip('/') + ('' if url.endswith('/v2') else '/v2')),
+    CredentialsValue(name='resource_group'),
+    CredentialsValue(name='cert_url', vcap_key=('credentials', 'certurl'),
+                     transform_fn=lambda url: url.rstrip('/') +
+                                              ('' if url.endswith(AUTH_ENDPOINT_SUFFIX) else AUTH_ENDPOINT_SUFFIX)),
+    # Even though the certificate and key in VCAP_SERVICES are not file paths, the names are defined this way in order
+    # to keep it compatible with the config names. It'll be handled in fetch_credentials function.
+    CredentialsValue(name='cert_file_path'),
+    CredentialsValue(name='key_file_path'),
+    CredentialsValue(name='cert_str', vcap_key=('credentials', 'certificate'),
+                     transform_fn=lambda cert_str: cert_str.replace('\\n', '\n')),
+    CredentialsValue(name='key_str', vcap_key=('credentials', 'key'),
+                     transform_fn=lambda key_str: key_str.replace('\\n', '\n'))
+]
+
+
+def init_conf(profile: str = None):
+    # Read configuration from ${AICORE_HOME}/config_<profile>.json.
+    home = pathlib.Path(get_home())
+    profile = profile or os.environ.get(PROFILE_ENV_VAR)
+    profile_config_file = f'config_{profile}.json'
+    direct_config_file = pathlib.Path(os.getenv(CONFIG_FILE_ENV_VAR)) if os.getenv(CONFIG_FILE_ENV_VAR) else None
+    path_to_config = (direct_config_file or
+                      (home / ('config.json' if profile in ('default', '', None) else profile_config_file)))
+    config = {}
+    if path_to_config.exists():
+        logger.debug('Config file path %s', path_to_config)
+        try:
+            with path_to_config.open(encoding='utf-8') as f:
+                return json.load(f)
+        except json.decoder.JSONDecodeError:
+            raise KeyError(f'{path_to_config} is not a valid json file. Please fix or remove it!')
+    elif profile:
+        raise FileNotFoundError(f"Unable to locate profile config file '{profile_config_file}' "
+                                f"in AICORE_HOME '{home}')")
+    return config
+
+
+def fetch_credentials(profile: str = None, **kwargs) -> Dict[str, str]:
+    config = init_conf(profile=profile)
+    try:
+        vcap_service = VCAPEnvironment.from_env()[VCAP_AICORE_SERVICE_NAME]
+    except KeyError:
+        vcap_service = None
+    credentials = {}
+    cred_value: CredentialsValue
+    for cred_value in CREDENTIAL_VALUES:
+        value = resolve_params(config, cred_value, vcap_service, **kwargs)
+        if value is not None:
+            if cred_value.transform_fn:
+                value = cred_value.transform_fn(value)
+            credentials[cred_value.name] = value
+    return credentials
+
+
+def resolve_params(config, cred_value, vcap_service, **kwargs):
+    """
+    Resolves the parameter value by checking multiple sources in order:
+    kwargs, environment variables, config, VCAP services, and defaults.
+    Logs the source of the resolved value.
+    """
+    env_var_name = f'{AI_CORE_PREFIX}_{cred_value.name.upper()}'
+    sources = {
+        "kwargs": kwargs.get(cred_value.name),
+        "environment variable": os.getenv(env_var_name),
+        "config file": config.get(env_var_name),
+        "VCAP service": vcap_service.get(cred_value.vcap_key, None) if vcap_service and cred_value.vcap_key else None,
+        "default value": cred_value.default,
+    }
+
+    # Find the first valid source and log it
+    for source, value in sources.items():
+        if value is not None:
+            logger.debug('Using source %s for %s', source, cred_value.name)
+            return value
+
+    # Default case (unlikely due to default in sources)
+    logger.debug('Using source %s for %s', 'default value', cred_value.name)
+    return cred_value.default

ai_core_sdk/exception.py

@@ -0,0 +1,11 @@
+from ai_api_client_sdk.exception import AIAPIAuthenticatorException, AIAPIAuthorizationException, \
+    AIAPIInvalidRequestException, AIAPINotFoundException, AIAPIPreconditionFailedException, \
+    AIAPIServerException
+
+
+class AICoreSDKException(Exception):
+    """Base Exception class for AI Core SDK exceptions"""
+
+
+class AICoreInvalidInputException(AICoreSDKException):
+    """Exception thrown in case of invalid input"""

ai_core_sdk/helpers/__init__.py

@@ -0,0 +1,39 @@
+import os
+from typing import Dict
+
+from ai_api_client_sdk.helpers.authenticator import Authenticator
+from .constants import DEFAULT_HOME_PATH, HOME_PATH_ENV_VAR
+
+
+def form_top_skip_params(top: int = None, skip: int = None) -> Dict[str, int]:
+    """
+    Frame query param
+
+    :param top: Number of objects to be retrieved, defaults to None
+    :type top: int, optional
+    :param skip: Number of objects to be skipped, from the list of the queried objects,
+        defaults to None
+    :type skip: int, optional
+    """
+    params = {}
+    if top:
+        params['$top'] = top
+    if skip:
+        params['$skip'] = skip
+    if not params:
+        params = None
+    return params
+
+
+def is_within_aicore() -> bool:
+    """[summary]
+    Function to check whether the sdk is used within or out of aicore cluster
+    Returns:
+        bool: True if the ai-core-sdk is used within aicore cluster
+              False if the ai-core-sdk is used outside aicore cluster
+    """
+    return os.getenv('AICORE_EXECUTION_ID') and os.getenv('AICORE_TRACKING_ENDPOINT')
+
+
+def get_home() -> str:
+    return os.environ.get(HOME_PATH_ENV_VAR, DEFAULT_HOME_PATH)

ai_core_sdk/helpers/constants.py

@@ -0,0 +1,18 @@
+import os
+from enum import Enum
+
+AI_CORE_PREFIX = 'AICORE'
+AUTH_ENDPOINT_SUFFIX = '/oauth/token'
+CONFIG_FILE_ENV_VAR = f'{AI_CORE_PREFIX}_CONFIG'
+DEBUG_ENV_VAR_NAME = "DEBUG"
+DEFAULT_HOME_PATH = os.path.join(os.path.expanduser('~'), '.aicore')
+HOME_PATH_ENV_VAR = f'{AI_CORE_PREFIX}_HOME'
+PROFILE_ENV_VAR = f'{AI_CORE_PREFIX}_PROFILE'
+VCAP_AICORE_SERVICE_NAME = 'aicore'
+VCAP_SERVICES_ENV_VAR = 'VCAP_SERVICES'
+
+
+class Timeouts(Enum):
+    READ_TIMEOUT = 60
+    CONNECT_TIMEOUT = 60
+    NUM_REQUEST_RETRIES = 3

ai_core_sdk/helpers/logging.py

@@ -0,0 +1,23 @@
+import logging
+import os
+
+from ai_core_sdk.helpers.constants import DEBUG_ENV_VAR_NAME
+
+BASE_LOGGER_NAME = "ai_core_sdk"
+DEFAULT_LOG_LEVEL = logging.INFO
+
+
+def get_logger(name: str = None):
+    # Use a hierarchical logger structure to allow for more granular control
+    logger_name = f"{name}" if name else BASE_LOGGER_NAME
+    return logging.getLogger(logger_name)
+
+
+def set_log_level(logger: logging.Logger, default_level=DEFAULT_LOG_LEVEL):
+    # Check if DEBUG is set to "true" (case-insensitive)
+    debug_env = os.getenv(DEBUG_ENV_VAR_NAME)
+    debug = debug_env is not None and debug_env.lower() == 'true'
+    logger.setLevel(logging.DEBUG if debug else default_level)
+
+
+set_log_level(get_logger())

ai_core_sdk/models/__init__.py

@@ -0,0 +1,33 @@
+from ai_api_client_sdk.models.artifact import Artifact
+from ai_api_client_sdk.models.base_models import (
+    BasicResponse,
+    KeyValue,
+    Name,
+    NameValue,
+    Order,
+    QueryResponse,
+)
+from ai_api_client_sdk.models.configuration import Configuration
+from ai_api_client_sdk.models.deployment import Deployment
+from ai_api_client_sdk.models.executable import Executable
+from ai_api_client_sdk.models.execution import Execution
+from ai_api_client_sdk.models.healthz_status import HealthzStatus
+from ai_api_client_sdk.models.input_artifact import InputArtifact
+from ai_api_client_sdk.models.input_artifact_binding import InputArtifactBinding
+from ai_api_client_sdk.models.label import Label
+from ai_api_client_sdk.models.metric import Metric
+from ai_api_client_sdk.models.metric_custom_info import MetricCustomInfo
+from ai_api_client_sdk.models.metric_label import MetricLabel
+from ai_api_client_sdk.models.metric_resource import MetricResource
+from ai_api_client_sdk.models.metric_tag import MetricTag
+from ai_api_client_sdk.models.metrics_query_response import MetricsQueryResponse
+from ai_api_client_sdk.models.model import Model
+from ai_api_client_sdk.models.model_query_response import ModelQueryResponse
+from ai_api_client_sdk.models.model_version import ModelVersion
+from ai_api_client_sdk.models.output_artifact import OutputArtifact
+from ai_api_client_sdk.models.parameter import Parameter
+from ai_api_client_sdk.models.parameter_binding import ParameterBinding
+from ai_api_client_sdk.models.scenario import Scenario
+from ai_api_client_sdk.models.status import Status
+from ai_api_client_sdk.models.target_status import TargetStatus
+from ai_api_client_sdk.models.version import Version