import json, warnings

import sys

if sys.version_info >= (3,0):

import urllib.parse

dku_quote_fn = urllib.parse.quote

else:

import urllib

dku_quote_fn = urllib.quote

from requests import Session

from requests import exceptions

from requests.auth import HTTPBasicAuth

from .iam.settings import DSSSSOSettings, DSSLDAPSettings, DSSAzureADSettings

from .dss.data_collection import DSSDataCollection, DSSDataCollectionListItem

from .dss.feature_store import DSSFeatureStore

from .dss.notebook import DSSNotebook

from .dss.future import DSSFuture

from .dss.projectfolder import DSSProjectFolder

from .dss.project import DSSProject

from .dss.app import DSSApp, DSSAppListItem

from .dss.plugin import DSSPlugin

from .dss.admin import DSSGlobalApiKeyListItem, DSSPersonalApiKeyListItem, DSSUser, DSSUserActivity, DSSOwnUser, DSSGroup, DSSConnection, DSSConnectionListItem, DSSGeneralSettings, DSSCodeEnv, DSSGlobalApiKey, DSSCluster, DSSCodeStudioTemplate, DSSCodeStudioTemplateListItem, DSSGlobalUsageSummary, DSSInstanceVariables, DSSPersonalApiKey, DSSAuthorizationMatrix, DSSLLMCostLimitingCounters

from .dss.messaging_channel import DSSMailMessagingChannel, DSSMessagingChannelListItem, DSSMessagingChannel

from .dss.meaning import DSSMeaning

from .dss.sqlquery import DSSSQLQuery

from .dss.discussion import DSSObjectDiscussions

from .dss.apideployer import DSSAPIDeployer

from .dss.projectdeployer import DSSProjectDeployer

from .dss.unifiedmonitoring import DSSUnifiedMonitoring

from .dss.utils import DSSInfoMessages, Enum

from .dss.workspace import DSSWorkspace

import os.path as osp

from .utils import dku_basestring_type, handle_http_exception

from .govern_client import GovernClient

class DSSClient(object):

"""Entry point for the DSS API client"""

def __init__(self, host, api_key=None, internal_ticket=None, extra_headers=None, no_check_certificate=False, **kwargs):

"""

Instantiate a new DSS API client on the given host with the given API key.

API keys can be managed in DSS on the project page or in the global settings.

The API key will define which operations are allowed for the client.

"""

if "insecure_tls" in kwargs:

# Backward compatibility before removing insecure_tls option

warnings.warn("insecure_tls field is now deprecated. It has been replaced by no_check_certificate.", DeprecationWarning)

no_check_certificate = kwargs.get("insecure_tls") or no_check_certificate

self.api_key = api_key

self.internal_ticket = internal_ticket

self.host = host

self._session = Session()

if no_check_certificate: # either True or a string in case of encrypted rpc

self._session.verify = no_check_certificate if isinstance(no_check_certificate, str) else False

if self.api_key is not None:

self._session.auth = HTTPBasicAuth(self.api_key, "")

elif self.internal_ticket is not None:

self._session.headers.update({"X-DKU-APITicket" : self.internal_ticket})

else:

raise ValueError("API Key is required")

if extra_headers is not None:

self._session.headers.update(extra_headers)

########################################################

# Futures

########################################################

def list_futures(self, as_objects=False, all_users=False):

"""

List the currently-running long tasks (a.k.a futures)

:param boolean as_objects: if True, each returned item will be a :class:`dataikuapi.dss.future.DSSFuture`

:param boolean all_users: if True, returns futures for all users (requires admin privileges). Else, only returns futures for the user associated with the current authentication context (if any)

:return: list of futures. if as_objects is True, each future in the list is a :class:`dataikuapi.dss.future.DSSFuture`. Else, each future in the list is a dict. Each dict contains at least a 'jobId' field

:rtype: list of :class:`dataikuapi.dss.future.DSSFuture` or list of dict

"""

list = self._perform_json("GET", "/futures/", params={"withScenarios":False, "withNotScenarios":True, 'allUsers' : all_users})

if as_objects:

return [DSSFuture(self, state['jobId'], state) for state in list]

else:

return list

def list_running_scenarios(self, all_users=False):

"""

List the running scenarios

:param boolean all_users: if True, returns scenarios for all users (requires admin privileges). Else, only returns scenarios for the user associated with the current authentication context (if any)

:return: list of running scenarios, each one as a dict containing at least a "jobId" field for the

future hosting the scenario run, and a "payload" field with scenario identifiers

:rtype: list of dicts

"""

return self._perform_json("GET", "/futures/", params={"withScenarios":True, "withNotScenarios":False, 'allUsers' : all_users})

def get_future(self, job_id):

"""

Get a handle to interact with a specific long task (a.k.a future). This notably allows aborting this future.

:param str job_id: the identifier of the desired future (which can be returned by :py:meth:`list_futures` or :py:meth:`list_running_scenarios`)

:returns: A handle to interact the future

:rtype: :class:`dataikuapi.dss.future.DSSFuture`

"""

return DSSFuture(self, job_id)

########################################################

# Notebooks

########################################################

def list_running_notebooks(self, as_objects=True):

"""

List the currently-running Jupyter notebooks

:param boolean as_objects: if True, each returned item will be a :class:`dataikuapi.dss.notebook.DSSNotebook`

:return: list of notebooks. if as_objects is True, each entry in the list is a :class:`dataikuapi.dss.notebook.DSSNotebook`. Else, each item in the list is a dict which contains at least a "name" field.

:rtype: list of :class:`dataikuapi.dss.notebook.DSSNotebook` or list of dict

"""

notebook_list = self._perform_json("GET", "/admin/notebooks/")

if as_objects:

return [DSSNotebook(self, notebook['projectKey'], notebook['name'], notebook) for notebook in notebook_list]

else:

return notebook_list

########################################################

# Project folders

########################################################

def get_root_project_folder(self):

"""

Get a handle to interact with the root project folder.

:returns: A :class:`dataikuapi.dss.projectfolder.DSSProjectFolder` to interact with this project folder

"""

return self.get_project_folder("ROOT")

def get_project_folder(self, project_folder_id):

"""

Get a handle to interact with a project folder.

:param str project_folder_id: the project folder ID of the desired project folder

:returns: A :class:`dataikuapi.dss.projectfolder.DSSProjectFolder` to interact with this project folder

"""

data = self._perform_json("GET", "/project-folders/%s" % project_folder_id)

return DSSProjectFolder(self, data)

########################################################

# Projects

########################################################

def list_project_keys(self):

"""

List the project keys (=project identifiers).

:returns: list of project keys identifiers, as strings

:rtype: list of strings

"""

return [x["projectKey"] for x in self._perform_json("GET", "/projects/")]

def list_projects(self):

"""

List the projects

:returns: a list of projects, each as a dict. Each dictcontains at least a 'projectKey' field

:rtype: list of dicts

"""

return self._perform_json("GET", "/projects/")

def get_project(self, project_key):

"""

Get a handle to interact with a specific project.

:param str project_key: the project key of the desired project

:returns: A :class:`dataikuapi.dss.project.DSSProject` to interact with this project

"""

return DSSProject(self, project_key)

def get_default_project(self):

"""

Get a handle to the current default project, if available (i.e. if dataiku.default_project_key() is valid)

"""

import dataiku

return DSSProject(self, dataiku.default_project_key())

def create_project(self, project_key, name, owner, description=None, settings=None, project_folder_id=None):

"""

Creates a new project, and return a project handle to interact with it.

Note: this call requires an API key with admin rights or the rights to create a project

:param str project_key: the identifier to use for the project. Must be globally unique

:param str name: the display name for the project.

:param str owner: the login of the owner of the project.

:param str description: a description for the project.

:param dict settings: Initial settings for the project (can be modified later). The exact possible settings are not documented.

:param str project_folder_id: the project folder ID in which the project will be created (root project folder if not specified)

:returns: A :class:`dataikuapi.dss.project.DSSProject` project handle to interact with this project

"""

params = {}

if project_folder_id is not None:

params["projectFolderId"] = project_folder_id

resp = self._perform_text(

"POST", "/projects/", body={

"projectKey" : project_key,

"name" : name,

"owner" : owner,

"settings" : settings,

"description" : description

}, params=params)

return DSSProject(self, project_key)

########################################################

# Apps

########################################################

def list_apps(self, as_type="listitems"):

"""

List the apps.

:param str as_type: How to return the list. Supported values are "listitems" and "objects" (defaults to **listitems**).

:returns: The list of the apps. If "as_type" is "listitems", each one as a :class:`dataikuapi.dss.app.DSSAppListItem`.

If "as_type" is "objects", each one as a :class:`dataikuapi.dss.app.DSSApp`

:rtype: list

"""

items = self._perform_json("GET", "/apps/")

if as_type == "listitems" or as_type == "listitem":

return [DSSAppListItem(self, item) for item in items]

elif as_type == "objects" or as_type == "object":

return [DSSApp(self, item["appId"]) for item in items]

else:

raise ValueError("Unknown as_type")

def get_app(self, app_id):

"""

Get a handle to interact with a specific app.

.. note::

If a project XXXX is an app template, the identifier of the associated app is PROJECT_XXXX

:param str app_id: the id of the desired app

:returns: A :class:`dataikuapi.dss.app.DSSApp` to interact with this project

"""

return DSSApp(self, app_id)

########################################################

# Plugins

########################################################

def list_plugins(self):

"""

List the installed plugins

:returns: list of dict. Each dict contains at least a 'id' field

"""

return self._perform_json("GET", "/plugins/")

def download_plugin_stream(self, plugin_id):

"""

Download a development plugin, as a binary stream

:param str plugin_id: identifier of the plugin to download

:param plugin_id:

:return: the binary stream

"""

return self._perform_raw("GET", "/plugins/%s/download" % plugin_id)

def download_plugin_to_file(self, plugin_id, path):

"""

Download a development plugin to a file

:param str plugin_id: identifier of the plugin to download

:param str path: the path where to download the plugin

:return: None

"""

stream = self.download_plugin_stream(plugin_id)

with open(path, 'wb') as f:

for chunk in stream.iter_content(chunk_size=10000):

if chunk:

f.write(chunk)

f.flush()

def install_plugin_from_archive(self, fp):

"""

Install a plugin from a plugin archive (as a file object)

:param object fp: A file-like object pointing to a plugin archive zip

"""

files = {'file': fp }

self._perform_json("POST", "/plugins/actions/installFromZip", files=files)

def start_install_plugin_from_archive(self, fp):

"""

Install a plugin from a plugin archive (as a file object)

Returns immediately with a future representing the process done asycnhronously

:param object fp: A file-like object pointing to a plugin archive zip

:return: A :class:`~dataikuapi.dss.future.DSSFuture` representing the install process

:rtype: :class:`~dataikuapi.dss.future.DSSFuture`

"""

files = {'file': fp }

f = self._perform_json("POST", "/plugins/actions/future/installFromZip", files=files)

return DSSFuture.from_resp(self, f)

def install_plugin_from_store(self, plugin_id):

"""

Install a plugin from the Dataiku plugin store

:param str plugin_id: identifier of the plugin to install

:return: A :class:`~dataikuapi.dss.future.DSSFuture` representing the install process

"""

f = self._perform_json("POST", "/plugins/actions/installFromStore", body={

"pluginId": plugin_id

})

return DSSFuture.from_resp(self, f)

def install_plugin_from_git(self, repository_url, checkout = "master", subpath=None):

"""

Install a plugin from a Git repository. DSS must be setup to allow access to the repository.

:param str repository_url: URL of a Git remote

:param str checkout: branch/tag/SHA1 to commit. For example "master"

:param str subpath: Optional, path within the repository to use as plugin. Should contain a 'plugin.json' file

:return: A :class:`~dataikuapi.dss.future.DSSFuture` representing the install process

"""

f = self._perform_json("POST", "/plugins/actions/installFromGit", body={

"gitRepositoryUrl": repository_url,

"gitCheckout" : checkout,

"gitSubpath": subpath

})

return DSSFuture.from_resp(self, f)

def get_plugin(self, plugin_id):

"""

Get a handle to interact with a specific plugin

:param str plugin_id: the identifier of the desired plugin

:returns: A :class:`dataikuapi.dss.project.DSSPlugin`

"""

return DSSPlugin(self, plugin_id)

########################################################

# SQL queries

########################################################

def sql_query(self, query, connection=None, database=None, dataset_full_name=None, pre_queries=None, post_queries=None, type='sql', extra_conf=None, script_steps=None, script_input_schema=None, script_output_schema=None, script_report_location=None, read_timestamp_without_timezone_as_string=True, read_date_as_string=False, project_key=None, datetimenotz_read_mode="AS_IS", dateonly_read_mode="AS_IS"):

"""

Initiate a SQL, Hive or Impala query and get a handle to retrieve the results of the query.

Internally, the query is run by DSS. The database to run the query on is specified either by

passing a connection name, or by passing a database name, or by passing a dataset full name

(whose connection is then used to retrieve the database)

:param str query: the query to run

:param str connection: the connection on which the query should be run (exclusive of database and dataset_full_name)

:param str database: the database on which the query should be run (exclusive of connection and dataset_full_name)

:param str dataset_full_name: the dataset on the connection of which the query should be run (exclusive of connection and database)

:param list pre_queries: (optional) array of queries to run before the query

:param list post_queries: (optional) array of queries to run after the query

:param str type: the type of query : either 'sql', 'hive' or 'impala' (default: sql)

:param str project_key: The project_key on which the query should be run (especially useful for user isolation/impersonation scenario)

:param str datetimenotz_read_mode: if set to 'AS_IS', read SQL data types that map to the 'datetime no tz' DSS type as such. If set

to 'AS_STRING', read them as strings, straight from the database (ie: conversion to string is

done by the database, according to its own settings). If set to 'AS_DATE', read them as the DSS 'datetime with tz'

type, in the UTC timezone. Default 'AS_IS'

:param str dateonly_read_mode: if set to 'AS_IS', read SQL data types that map to the 'date only' DSS type as such. If set

to 'AS_STRING', read them as strings, straight from the database. If set to 'AS_DATE', read them as the

DSS 'datetime with tz' type, in the UTC timezone. Default 'AS_IS'

:return: a handle on the SQL query

:rtype: :class:`dataikuapi.dss.sqlquery.DSSSQLQuery`

"""

if extra_conf is None:

extra_conf = {}

return DSSSQLQuery(self, query, connection, database, dataset_full_name, pre_queries, post_queries, type, extra_conf, script_steps, script_input_schema, script_output_schema, script_report_location, read_timestamp_without_timezone_as_string, read_date_as_string, datetimenotz_read_mode, dateonly_read_mode, project_key)

########################################################

# Users

########################################################

def list_users(self, as_objects=False):

"""

List all users setup on the DSS instance

Note: this call requires an API key with admin rights

:return: A list of users, as a list of :class:`dataikuapi.dss.admin.DSSUser` if as_objects is True, else as a list of dicts

:rtype: list of :class:`dataikuapi.dss.admin.DSSUser` or list of dicts

"""

users = self._perform_json("GET", "/admin/users/")

if as_objects:

return [DSSUser(self, user["login"]) for user in users]

else:

return users

def get_user(self, login):

"""

Get a handle to interact with a specific user

:param str login: the login of the desired user

:return: A :class:`dataikuapi.dss.admin.DSSUser` user handle

"""

return DSSUser(self, login)

def create_user(self, login, password, display_name='', source_type='LOCAL', groups=None, profile='DATA_SCIENTIST', email=None):

"""

Create a user, and return a handle to interact with it

Note: this call requires an API key with admin rights

:param str login: the login of the new user

:param str password: the password of the new user

:param str display_name: the displayed name for the new user

:param str source_type: the type of new user. Admissible values are 'LOCAL' or 'LDAP'

:param list groups: the names of the groups the new user belongs to (defaults to `[]`)

:param str profile: The profile for the new user. Typical values (depend on your license): FULL_DESIGNER, DATA_DESIGNER, AI_CONSUMER, ...

:param str email: The email for the new user.

:return: A :class:`dataikuapi.dss.admin.DSSUser` user handle

"""

if groups is None:

groups = []

resp = self._perform_text(

"POST", "/admin/users/", body={

"login" : login,

"password" : password,

"displayName" : display_name,

"sourceType" : source_type,

"groups" : groups,

"userProfile" : profile,

"email": email

})

return DSSUser(self, login)

def get_own_user(self):

return DSSOwnUser(self)

def list_users_activity(self, enabled_users_only=False):

"""

List all users activity

Note: this call requires an API key with admin rights

:return: A list of user activity logs, as a list of :class:`dataikuapi.dss.admin.DSSUserActivity` if as_objects is True, else as a list of dict

:rtype: list of :class:`dataikuapi.dss.admin.DSSUserActivity` or a list of dict

"""

params = {

"enabledUsersOnly": enabled_users_only

}

all_activity = self._perform_json("GET", "/admin/users-activity", params=params)

return [DSSUserActivity(self, user_activity["login"], user_activity) for user_activity in all_activity]

def list_expired_trial_users(self):

"""

List users whose trials have expired

:return: A list of users

"""

users = self._perform_json("GET", "/admin/list-trial-expired-users")

return users

def get_authorization_matrix(self):

"""

Get the authorization matrix for all enabled users and groups

Note: this call requires an API key with admin rights

:return: The authorization matrix

:rtype: A :class:`dataikuapi.dss.admin.DSSAuthorizationMatrix` authorization matrix handle

"""

resp = self._perform_json("GET", "/admin/authorization-matrix")

return DSSAuthorizationMatrix(resp)

def start_resync_users_from_supplier(self, logins):

"""

Starts a resync of multiple users from an external supplier (LDAP, Azure AD or custom auth)

:param list logins: list of logins to resync

:return: a :class:`dataikuapi.dss.future.DSSFuture` representing the sync process

:rtype: :class:`dataikuapi.dss.future.DSSFuture`

"""

future_resp = self._perform_json("POST", "/admin/users/actions/resync-multi", body=logins)

return DSSFuture.from_resp(self, future_resp)

def start_resync_all_users_from_supplier(self):

"""

Starts a resync of all users from an external supplier (LDAP, Azure AD or custom auth)

:return: a :class:`dataikuapi.dss.future.DSSFuture` representing the sync process

:rtype: :class:`dataikuapi.dss.future.DSSFuture`

"""

future_resp = self._perform_json("POST", "/admin/users/actions/resync-multi")

return DSSFuture.from_resp(self, future_resp)

def start_fetch_external_groups(self, user_source_type):

"""

Fetch groups from external source

:param user_source_type: 'LDAP', 'AZURE_AD' or 'CUSTOM'

:rtype: :class:`dataikuapi.dss.future.DSSFuture`

:return: a DSSFuture containing a list of group names

"""

future_resp = self._perform_json("GET", "/admin/external-groups", params={'userSourceType': user_source_type})

return DSSFuture.from_resp(self, future_resp)

def start_fetch_external_users(self, user_source_type, login=None, group_name=None):

"""

Fetch users from external source filtered by login or group name:

- if login is provided, will search for a user with an exact match in the external source (e.g. before login remapping)

- else,

- if group_name is provided, will search for members of the group in the external source

- else will search for all users

:param user_source_type: 'LDAP', 'AZURE_AD' or 'CUSTOM'

:param login: optional - the login of the user in the external source

:param group_name: optional - the group name of the group in the external source

:rtype: :class:`dataikuapi.dss.future.DSSFuture`

:return: a DSSFuture containing a list of ExternalUser

"""

future_resp = self._perform_json("GET", "/admin/external-users", params={'userSourceType': user_source_type, 'login': login, 'groupName': group_name})

return DSSFuture.from_resp(self, future_resp)

def start_provision_users(self, user_source_type, users):

"""

Provision users of given source type

:param string user_source_type: 'LDAP', 'AZURE_AD' or 'CUSTOM'

:param list users: list of user attributes coming form the external source

:rtype: :class:`dataikuapi.dss.future.DSSFuture`

"""

future_resp = self._perform_json("POST", "/admin/users/actions/provision", body={'userSourceType': user_source_type, 'users': users})

return DSSFuture.from_resp(self, future_resp)

########################################################

# Groups

########################################################

def list_groups(self):

"""

List all groups setup on the DSS instance

Note: this call requires an API key with admin rights

:returns: A list of groups, as an list of dicts

:rtype: list of dicts

"""

return self._perform_json(

"GET", "/admin/groups/")

def get_group(self, name):

"""

Get a handle to interact with a specific group

:param str name: the name of the desired group

:returns: A :class:`dataikuapi.dss.admin.DSSGroup` group handle

"""

return DSSGroup(self, name)

def create_group(self, name, description=None, source_type='LOCAL'):

"""

Create a group, and return a handle to interact with it

Note: this call requires an API key with admin rights

:param str name: the name of the new group

:param str description: (optional) a description of the new group

:param source_type: the type of the new group. Admissible values are 'LOCAL' and 'LDAP'

:returns: A :class:`dataikuapi.dss.admin.DSSGroup` group handle

"""

resp = self._perform_text(

"POST", "/admin/groups/", body={

"name" : name,

"description" : description,

"sourceType" : source_type

})

return DSSGroup(self, name)

########################################################

# Connections

########################################################

def list_connections(self, as_type="dictitems"):

"""

List all connections setup on the DSS instance.

.. note::

This call requires an API key with admin rights

:param string as_type: how to return the connection. Possible values are "dictitems", "listitems" and "objects"

:return: if **as_type** is dictitems, a dict of connection name to :class:`dataikuapi.dss.admin.DSSConnectionListItem`.

if **as_type** is listitems, a list of :class:`dataikuapi.dss.admin.DSSConnectionListItem`.

if **as_type** is objects, a list of :class:`dataikuapi.dss.admin.DSSConnection`.

:rtype: dict or list

"""

items_dict = self._perform_json(

"GET", "/admin/connections/")

if as_type == "dictitems" or as_type == "dictitem":

return {name:DSSConnectionListItem(self, items_dict[name]) for name in items_dict.keys()}

if as_type == "listitems" or as_type == "listitem":

return [DSSConnectionListItem(self, items_dict[name]) for name in items_dict.keys()]

elif as_type == "objects" or as_type == "object":

return [DSSConnection(self, name) for name in items_dict.keys()]

else:

raise ValueError("Unknown as_type")

def list_connections_names(self, connection_type):

"""

List all connections names on the DSS instance.

:param str connection_type: Returns only connections with this type. Use 'all' if you don't want to filter.

:return: the list of connections names

:rtype: List[str]

"""

return self._perform_json("GET", "/connections/get-names", params={"type": connection_type})

def get_connection(self, name):

"""

Get a handle to interact with a specific connection

:param str name: the name of the desired connection

:returns: A :class:`dataikuapi.dss.admin.DSSConnection` connection handle

"""

return DSSConnection(self, name)

def create_connection(self, name, type, params=None, usable_by='ALL', allowed_groups=None):

"""

Create a connection, and return a handle to interact with it

Note: this call requires an API key with admin rights

:param name: the name of the new connection

:param type: the type of the new connection

:param dict params: the parameters of the new connection, as a JSON object (defaults to `{}`)

:param usable_by: the type of access control for the connection. Either 'ALL' (=no access control)

or 'ALLOWED' (=access restricted to users of a list of groups)

:param list allowed_groups: when using access control (that is, setting usable_by='ALLOWED'), the list

of names of the groups whose users are allowed to use the new connection (defaults to `[]`)

:returns: A :class:`dataikuapi.dss.admin.DSSConnection` connection handle

"""

if params is None:

params = {}

if allowed_groups is None:

allowed_groups = []

resp = self._perform_text(

"POST", "/admin/connections/", body={

"name" : name,

"type" : type,

"params" : params,

"usableBy" : usable_by,

"allowedGroups" : allowed_groups

})

return DSSConnection(self, name)

########################################################

# Code envs

########################################################

def list_code_envs(self, as_objects=False):

"""

List all code envs setup on the DSS instance

:param boolean as_objects: if True, each returned item will be a :class:`dataikuapi.dss.future.DSSCodeEnv`

:returns: a list of code envs. Each code env is a dict containing at least "name", "type" and "language"

"""

list = self._perform_json(

"GET", "/admin/code-envs/")

if as_objects:

return [DSSCodeEnv(self, e.get("envLang"), e.get("envName")) for e in list]

else:

return list

def get_code_env(self, env_lang, env_name):

"""

Get a handle to interact with a specific code env

:param env_lang: the language (PYTHON or R) of the new code env

:param env_name: the name of the new code env

:returns: A :class:`dataikuapi.dss.admin.DSSCodeEnv` code env handle

"""

return DSSCodeEnv(self, env_lang, env_name)

def create_code_env(self, env_lang, env_name, deployment_mode, params=None):

"""

Create a code env, and return a handle to interact with it

Note: this call requires an API key with `Create code envs` or `Manage all code envs` permission

:param env_lang: the language (PYTHON or R) of the new code env

:param env_name: the name of the new code env

:param deployment_mode: the type of the new code env

:param params: the parameters of the new code env, as a JSON object

:returns: A :class:`dataikuapi.dss.admin.DSSCodeEnv` code env handle

"""

params = params if params is not None else {}

params['deploymentMode'] = deployment_mode

resp = self._perform_json(

"POST", "/admin/code-envs/%s/%s" % (env_lang, env_name), body=params)

if resp is None:

raise Exception('Env creation returned no data')

if resp.get('messages', {}).get('error', False):

raise Exception('Env creation failed : %s' % (json.dumps(resp.get('messages', {}).get('messages', {}))))

return DSSCodeEnv(self, env_lang, env_name)

def list_code_env_usages(self):

"""

List all usages of a code env in the instance

:return: a list of objects where the code env is used

"""

return self._perform_json("GET", "/admin/code-envs/usages")

def create_code_env_from_python_preset(self, preset_name, allow_update=True, interpreter=None, prefix=None):

request_params = {

'allowUpdate': allow_update,

'interpreter': interpreter,

'prefix': prefix

}

return self._perform_json("POST", "/admin/code-envs/from-python-preset/%s" % (preset_name), params=request_params)

########################################################

# Clusters

########################################################

def list_clusters(self):

"""

List all clusters setup on the DSS instance

Returns:

List clusters (name, type, state)

"""

return self._perform_json(

"GET", "/admin/clusters/")

def get_cluster(self, cluster_id):

"""

Get a handle to interact with a specific cluster

Args:

name: the name of the desired cluster

Returns:

A :class:`dataikuapi.dss.admin.DSSCluster` cluster handle

"""

return DSSCluster(self, cluster_id)

def create_cluster(self, cluster_name, cluster_type='manual', params=None, cluster_architecture='HADOOP'):

"""

Create a cluster, and return a handle to interact with it

:param cluster_name: the name of the new cluster

:param cluster_type: the type of the new cluster

:param params: the parameters of the new cluster, as a JSON object

:param cluster_architecture: the architecture of the new cluster. 'HADOOP' or 'KUBERNETES'

:returns: A :class:`dataikuapi.dss.admin.DSSCluster` cluster handle

"""

definition = {}

definition['name'] = cluster_name

definition['type'] = cluster_type

definition['architecture'] = cluster_architecture

definition['params'] = params if params is not None else {}

resp = self._perform_json(

"POST", "/admin/clusters/", body=definition)

if resp is None:

raise Exception('Cluster creation returned no data')

if resp.get('messages', {}).get('error', False):

raise Exception('Cluster creation failed : %s' % (json.dumps(resp.get('messages', {}).get('messages', {}))))

return DSSCluster(self, resp['id'])

########################################################

# Code studio templates

########################################################

def list_code_studio_templates(self, as_type='listitems'):

"""

List all code studio templates on the DSS instance

:returns: List of templates (name, type)

"""

items = self._perform_json("GET", "/admin/code-studios/")

if as_type == "listitems" or as_type == "listitem":

return [DSSCodeStudioTemplateListItem(self, item) for item in items]

elif as_type == "objects" or as_type == "object":

return [DSSCodeStudioTemplate(self, item["id"]) for item in items]

else:

raise ValueError("Unknown as_type")

def get_code_studio_template(self, template_id):

"""

Get a handle to interact with a specific code studio template

:param str template_id: the template id of the desired code studio template

:returns: A :class:`dataikuapi.dss.admin.DSSCodeStudioTemplate` code studio template handle

"""

return DSSCodeStudioTemplate(self, template_id)

########################################################

# Global API Keys

########################################################

def list_global_api_keys(self, as_type='listitems'):

"""

List all global API keys set up on the DSS instance

.. note::

This call requires an API key with admin rights

.. note::

If the secure API keys feature is enabled, the secret key of the listed

API keys will not be present in the returned objects

:param str as_type: How to return the global API keys. Possible values are "listitems" and "objects"

:return: if as_type=listitems, each key as a :class:`dataikuapi.dss.admin.DSSGlobalApiKeyListItem`.

if as_type=objects, each key is returned as a :class:`dataikuapi.dss.admin.DSSGlobalApiKey`.

"""

resp = self._perform_json(

"GET", "/admin/global-api-keys/")

if as_type == "listitems":

return [DSSGlobalApiKeyListItem(self, item) for item in resp]

elif as_type == 'objects':

return [DSSGlobalApiKey(self, item["key"], item["id"]) for item in resp]

else:

raise ValueError("Unknown as_type")

def get_global_api_key(self, key):

"""

Get a handle to interact with a specific Global API key

.. deprecated:: 13.0.0

Use :meth:`DSSClient.get_global_api_key_by_id`. Calling this method with an invalid secret key

will now result in an immediate error.

:param str key: the secret key of the API key

:returns: A :class:`dataikuapi.dss.admin.DSSGlobalApiKey` API key handle

"""

resp = self._perform_json(

"GET", "/admin/globalAPIKeys/%s" % key)

return DSSGlobalApiKey(self, key, resp['id'])

def get_global_api_key_by_id(self, id_):

"""

Get a handle to interact with a specific Global API key

:param str id_: the id the API key

:returns: A :class:`dataikuapi.dss.admin.DSSGlobalApiKey` API key handle

"""

resp = self._perform_json(

"GET", "/admin/global-api-keys/%s" % id_)

return DSSGlobalApiKey(self, resp["key"], id_)

def create_global_api_key(self, label=None, description=None, admin=False):

"""

Create a Global API key, and return a handle to interact with it

.. note::

This call requires an API key with admin rights

.. note::

The secret key of the created API key will always be present in the returned object,

even if the secure API keys feature is enabled

:param str label: the label of the new API key

:param str description: the description of the new API key

:param boolean admin: has the new API key admin rights (True or False)

:returns: A :class:`dataikuapi.dss.admin.DSSGlobalApiKey` API key handle

"""

resp = self._perform_json(

"POST", "/admin/global-api-keys/", body={

"label": label,

"description": description,

"globalPermissions": {

"admin": admin

}

})

if resp is None:

raise Exception('API key creation returned no data')

if resp.get('messages', {}).get('error', False):

raise Exception('API key creation failed : %s' % (json.dumps(resp.get('messages', {}).get('messages', {}))))

if not resp.get('id', False):

raise Exception('API key creation returned no key')

return DSSGlobalApiKey(self, resp.get('key', ''), resp['id'])

########################################################

# Personal API Keys

########################################################

def list_personal_api_keys(self, as_type='listitems'):

"""

List all your personal API keys.

:param str as_type: How to return the personal API keys. Possible values are "listitems" and "objects"

:return: if as_type=listitems, each key as a :class:`dataikuapi.dss.admin.DSSPersonalApiKeyListItem`.

if as_type=objects, each key is returned as a :class:`dataikuapi.dss.admin.DSSPersonalApiKey`.

"""

resp = self._perform_json(

"GET", "/personal-api-keys/")

if as_type == "listitems":

return [DSSPersonalApiKeyListItem(self, item) for item in resp]

elif as_type == 'objects':

return [DSSPersonalApiKey(self, item.get('key', ''), item['id']) for item in resp]

else:

raise ValueError("Unknown as_type")

def get_personal_api_key(self, id):

"""

Get a handle to interact with a specific Personal API key.

:param str id: the id of the desired API key

:returns: A :class:`dataikuapi.dss.admin.DSSPersonalApiKey` API key handle

"""

return DSSPersonalApiKey(self, "", id)

def create_personal_api_key(self, label="", description="", as_type='dict'):

"""

Create a Personal API key associated with your user.

:param str label: the label of the new API key

:param str description: the description of the new API key

:param str as_type: How to return the personal API keys. Possible values are "dict" and "object"

:return: if as_type=dict, the new personal API key is returned as a dict.

if as_type=object, the new personal API key is returned as a :class:`dataikuapi.dss.admin.DSSPersonalApiKey`.

"""

resp = self._perform_json(

"POST", "/personal-api-keys/", body={"label": label, "description": description})

if resp is None:

raise Exception('API key creation returned no data')

if not resp.get('id', False):

raise Exception('API key creation returned no key')

if as_type == 'object':

return DSSPersonalApiKey(self, resp.get('key', ''), resp["id"])

else:

return resp

def list_all_personal_api_keys(self, as_type='listitems'):

"""

List all personal API keys.

Only admin can list all the keys.

:param str as_type: How to return the personal API keys. Possible values are "listitems" and "objects"

:return: if as_type=listitems, each key as a :class:`dataikuapi.dss.admin.DSSPersonalApiKeyListItem`.

if as_type=objects, each key is returned as a :class:`dataikuapi.dss.admin.DSSPersonalApiKey`.

"""

resp = self._perform_json(

"GET", "/admin/personal-api-keys/")

if as_type == "listitems":

return [DSSPersonalApiKeyListItem(self, item) for item in resp]

elif as_type == 'objects':

return [DSSPersonalApiKey(self, item.get('key', ''), item['id']) for item in resp]

else:

raise ValueError("Unknown as_type")

def create_personal_api_key_for_user(self, user, label="", description="", as_type='object'):

"""

Create a Personal API key associated on behalf of a user.

Only admin can create a key for another user.

:param str label: the label of the new API key

:param str description: the description of the new API key

:param str user: the id of the user to impersonate

:param str as_type: How to return the personal API keys. Possible values are "dict" and "object"

:return: if as_type=dict, the new personal API key is returned as a dict.

if as_type=object, the new personal API key is returned as a :class:`dataikuapi.dss.admin.DSSPersonalApiKey`.

"""