Publish 13.5.3 on PyPI (#326)

* Sync sources with main repository

* Release metadata

Author: kevanescence

HISTORY.txt

@@ -2,6 +2,11 @@ Changelog
 ==========
 
 
+13.5.3 (2025-05-15)
+---------------------
+
+* Initial release for DSS 13.5.3
+
 13.5.2 (2025-05-12)
 ---------------------
 

dataikuapi/dss/admin.py

@@ -637,10 +637,10 @@ def get_client_as(self):
         if self.client.api_key is not None:
             return DSSClient(self.client.host, self.client.api_key, extra_headers={"X-DKU-ProxyUser":  self.login}, no_check_certificate=not self.client._session.verify, client_certificate=self.client._session.cert)
         elif self.client.internal_ticket is not None:
-            verify = self.client._session.verify
-            no_check_certificate = verify if isinstance(verify, str) else not verify
-            return DSSClient(self.client.host, internal_ticket = self.client.internal_ticket,
-                                         extra_headers={"X-DKU-ProxyUser":  self.login}, no_check_certificate=no_check_certificate, client_certificate=self.client._session.cert)
+            client_as = DSSClient(self.client.host, internal_ticket = self.client.internal_ticket,
+                                         extra_headers={"X-DKU-ProxyUser":  self.login}, client_certificate=self.client._session.cert)
+            client_as._session.verify = self.client._session.verify
+            return client_as
         else:
             raise ValueError("Don't know how to proxy this client")
 

dataikuapi/dss/knowledgebank.py

@@ -1,4 +1,4 @@
-from .utils import DSSTaggableObjectListItem
+from .utils import DSSTaggableObjectListItem, DSSTaggableObjectSettings
 
 class DSSKnowledgeBankListItem(DSSTaggableObjectListItem):
     """
@@ -64,7 +64,11 @@ class DSSKnowledgeBank(object):
     def __init__(self, client, project_key, id):
         self.client = client
         self.project_key = project_key
-        self.id = id
+        self._id = id
+
+    @property
+    def id(self):
+        return self._id
 
     def as_core_knowledge_bank(self):
         """
@@ -73,4 +77,102 @@ def as_core_knowledge_bank(self):
         :rtype: :class:`dataiku.KnowledgeBank`
         """
         import dataiku
-        return dataiku.KnowledgeBank("%s.%s" % (self.project_key, self.id))
+        return dataiku.KnowledgeBank("%s.%s" % (self.project_key, self.id))
+
+    def get_settings(self):
+        """
+        Get the knowledge bank's definition
+
+        :return: a handle on the knowledge bank definition
+        :rtype: :class:`dataikuapi.dss.knowledgebank.DSSKnowledgeBankSettings`
+        """
+        settings = self.client._perform_json(
+            "GET", "/projects/%s/knowledge-banks/%s" % (self.project_key, self.id))
+        return DSSKnowledgeBankSettings(self.client, settings)
+
+    def delete(self):
+        """
+        Delete the knowledge bank
+        """
+        return self.client._perform_empty("DELETE", "/projects/%s/knowledge-banks/%s" % (self.project_key, self.id))
+
+    def build(self, job_type="NON_RECURSIVE_FORCED_BUILD", wait=True):
+        """
+        Start a new job to build this knowledge bank and wait for it to complete.
+        Raises if the job failed.
+
+        .. code-block:: python
+
+            job = knowledge_bank.build()
+            print("Job %s done" % job.id)
+
+        :param job_type: the job type. One of RECURSIVE_BUILD, NON_RECURSIVE_FORCED_BUILD or RECURSIVE_FORCED_BUILD
+        :param bool wait: whether to wait for the job completion before returning the job handle, defaults to True
+        :returns: the :class:`dataikuapi.dss.job.DSSJob` job handle corresponding to the built job
+        :rtype: :class:`dataikuapi.dss.job.DSSJob`
+        """
+        project = self.client.get_project(self.project_key)
+        jd = project.new_job(job_type)
+        jd.with_output(self._id, object_type="RETRIEVABLE_KNOWLEDGE")
+        if wait:
+            return jd.start_and_wait()
+        else:
+            return jd.start()
+
+class DSSKnowledgeBankSettings(DSSTaggableObjectSettings):
+    """
+    Settings for a knowledge bank
+
+    .. important::
+
+        Do not instantiate directly, use :meth:`dataikuapi.dss.knowledgebank.DSSKnowledgeBank.get_settings` instead
+
+    """
+    def __init__(self, client, settings):
+        super(DSSKnowledgeBankSettings, self).__init__(settings)
+        self._client = client
+        self._settings = settings
+
+    @property
+    def project_key(self):
+        """
+        Returns the project key of the knowledge bank
+
+        :rtype: str
+        """
+        return self._settings['projectKey']
+
+    @property
+    def id(self):
+        """
+        Returns the identifier of the knowledge bank
+
+        :rtype: str
+        """
+        return self._settings['id']
+
+    @property
+    def vector_store_type(self):
+        """
+        Returns the type of storage backing the vector store (could be CHROMA, PINECONE, ELASTICSEARCH, AZURE_AI_SEARCH, VERTEX_AI_GCS_BASED, FAISS, QDRANT_LOCAL)
+
+        :rtype: str
+        """
+        return self._settings['vectorStoreType']
+
+    def get_raw(self):
+        """
+        Returns the raw settings of the knowledge bank
+
+        :return: the raw settings of the knowledge bank
+        :rtype: dict
+        """
+        return self._settings
+
+    def save(self):
+        """
+        Saves the settings on the knowledge bank
+        """
+        self._client._perform_json(
+            "PUT", "/projects/%s/knowledge-banks/%s" % (self.project_key, self.id),
+            body=self._settings)

dataikuapi/dss/langchain/embeddings.py

@@ -12,8 +12,7 @@
 except ModuleNotFoundError:
     from langchain.embeddings.base import Embeddings
 from langchain_core.callbacks import BaseCallbackHandler, LLMManagerMixin
-from dataiku.llm.tracing import SpanBuilder
-from dataikuapi.dss.llm_tracing import new_trace
+from dataikuapi.dss.llm_tracing import new_trace, SpanBuilder
 
 from dataikuapi.dss.langchain.utils import must_use_deprecated_pydantic_config
 

dataikuapi/dss/project.py

@@ -990,7 +990,7 @@ def list_saved_models(self):
         List the saved models in this project
 
         :returns: the list of the saved models, each one as a python dict
-        :rtype: list
+        :rtype: list[DSSSavedModel]
         """
         return self.client._perform_json(
             "GET", "/projects/%s/savedmodels/" % self.project_key)
@@ -1329,7 +1329,7 @@ def start_job(self, definition):
             * the type of job (RECURSIVE_BUILD, NON_RECURSIVE_FORCED_BUILD, RECURSIVE_FORCED_BUILD,\
                 RECURSIVE_MISSING_ONLY_BUILD)
             * a list of outputs to build from the available types: (DATASET, MANAGED_FOLDER, SAVED_MODEL,\
-                STREAMING_ENDPOINT)
+                STREAMING_ENDPOINT, KNOWLEDGE_BANK)
             * (Optional) a refreshHiveMetastore field (True or False) to specify whether to re-synchronize the Hive\
                 metastore for recomputed HDFS datasets.
             * (Optional) a autoUpdateSchemaBeforeEachRecipeRun field (True or False) to specify whether to auto update\
@@ -1350,7 +1350,7 @@ def start_job_and_wait(self, definition, no_fail=False):
             * the type of job (RECURSIVE_BUILD, NON_RECURSIVE_FORCED_BUILD, RECURSIVE_FORCED_BUILD,\
                 RECURSIVE_MISSING_ONLY_BUILD)
             * a list of outputs to build from the available types: (DATASET, MANAGED_FOLDER, SAVED_MODEL,\
-                STREAMING_ENDPOINT)
+                STREAMING_ENDPOINT, KNOWLEDGE_BANK)
             * (Optional) a refreshHiveMetastore field (True or False) to specify whether to re-synchronize the Hive\
                 metastore for recomputed HDFS datasets.
             * (Optional) a autoUpdateSchemaBeforeEachRecipeRun field (True or False) to specify whether to auto update\
@@ -1799,6 +1799,14 @@ def preload_bundle(self, bundle_id):
                                          "/projects/%s/bundles/imported/%s/actions/preload" % (
                                          self.project_key, bundle_id))
 
+    def delete_imported_bundle(self, bundle_id):
+        """
+        Deletes a bundle that has been imported on the Automation node
+
+        :param str bundle_id: The identifier of the bundle
+        """
+        return self.client._perform_json("DELETE", "/projects/%s/bundles/imported/%s" % (self.project_key, bundle_id))
+
     ########################################################
     # Testing with DSS test scenarios report
     ########################################################
@@ -2392,7 +2400,7 @@ def list_knowledge_banks(self, as_type="listitems"):
         :param str as_type: How to return the list. Supported values are "listitems" and "objects".
         :returns: The list of knowledge banks. If "as_type" is "listitems", each one as a :class:`dataikuapi.dss.knowledgebank.DSSKnowledgeBankListItem`.
                   If "as_type" is "objects", each one as a :class:`dataikuapi.dss.knowledgebank.DSSKnowledgeBank`
-        :rtype: list
+        :rtype: list[DSSKnowledgeBank]
         """
         kbs = self.client._perform_json("GET", "/projects/%s/knowledge-banks" % (self.project_key))
         if as_type == "listitems":
@@ -2411,6 +2419,36 @@ def get_knowledge_bank(self, id):
         """
         return DSSKnowledgeBank(self.client, self.project_key, id)
 
+    def create_knowledge_bank(self, name, vector_store_type, embedding_llm_id, settings=None):
+        """
+        Create a new knowledge bank in the project, and return a handle to interact with it
+
+        :param str name: The name for the new knowledge bank. This does not need to be unique
+
+        :param str vector_store_type: The vector store type to use for this knowledge bank. Valid values are:
+
+            * CHROMA
+            * PINECONE
+            * ELASTICSEARCH
+            * AZURE_AI_SEARCH
+            * VERTEX_AI_GCS_BASED
+            * FAISS *(not recommended)*
+            * QDRANT_LOCAL *(not recommended)*
+
+        :param str embedding_llm_id: The id of the embedding LLM. It has to have the TEXT_EMBEDDING_EXTRACTION purpose.
+
+        :param Optional[dict] settings: Additional settings for the knowledge bank.
+
+        :returns: a :class:`dataikuapi.dss.knowledgebank.DSSKnowledgeBank` handle to interact with the newly-created knowledge bank
+        """
+        if settings is None:
+            settings = {}
+        settings['name'] = name
+        settings['vectorStoreType'] = vector_store_type
+        settings['embeddingLLMId'] = embedding_llm_id
+
+        kb = self.client._perform_json("POST", "/projects/%s/knowledge-banks/" % self.project_key, body=settings)
+        return DSSKnowledgeBank(self.client, self.project_key, kb["id"])
 
     ########################################################
     # Agent Tools
@@ -3206,7 +3244,8 @@ def with_output(self, name, object_type=None, object_project_key=None, partition
         Adds an item to build in this job
 
         :param name: name of the output object
-        :param object_type: type of object to build from: DATASET, MANAGED_FOLDER, SAVED_MODEL, STREAMING_ENDPOINT
+        :param object_type: type of object to build from: DATASET, MANAGED_FOLDER, SAVED_MODEL, STREAMING_ENDPOINT,\
+            KNOWLEDGE_BANK
             (defaults to **None**)
         :param object_project_key: PROJECT_KEY for the project that contains the object to build (defaults to **None**)
         :param partition: specify partition to build (defaults to **None**)

dataikuapi/dss/recipe.py

@@ -140,7 +140,7 @@ def run(self, job_type="NON_RECURSIVE_FORCED_BUILD", partitions=None, wait=True,
                                   identifiers, and a partition identifier is a pipe-separated list of values for the partitioning
                                   dimensions
         :param boolean no_fail: if True, does not raise if the job failed
-        :param boolean wait: if True, the method waits for the job complettion. If False, the method returns immediately
+        :param boolean wait: if True, the method waits for the job completion. If False, the method returns immediately
 
         :return: a job handle corresponding to the recipe run
         :rtype: :class:`dataikuapi.dss.job.DSSJob`
@@ -158,7 +158,8 @@ def run(self, job_type="NON_RECURSIVE_FORCED_BUILD", partitions=None, wait=True,
             "COMPUTABLE_FOLDER": "MANAGED_FOLDER",
             "COMPUTABLE_SAVED_MODEL": "SAVED_MODEL",
             "COMPUTABLE_STREAMING_ENDPOINT": "STREAMING_ENDPOINT",
-            "COMPUTABLE_MODEL_EVALUATION_STORE": "MODEL_EVALUATION_STORE"
+            "COMPUTABLE_MODEL_EVALUATION_STORE": "MODEL_EVALUATION_STORE",
+            "COMPUTABLE_RETRIEVABLE_KNOWLEDGE": "RETRIEVABLE_KNOWLEDGE"
         }
         if first_output["type"] in object_type_map:
             jd = project.new_job(job_type)

dataikuapi/dssclient.py

@@ -47,7 +47,7 @@ def __init__(self, host, api_key=None, internal_ticket=None, extra_headers=None,
             api_key (str, optional): API key for authentication. Can be managed in DSS project page or global settings.
             internal_ticket (str, optional): Internal ticket for authentication.
             extra_headers (dict, optional): Additional HTTP headers to include in requests.
-            no_check_certificate (bool or str, optional): If True, disables SSL certificate verification. 
+            no_check_certificate (bool, optional): If True, disables SSL certificate verification. 
                 Defaults to False.
             client_certificate (str or tuple, optional): Path to client certificate file or tuple of (cert, key) paths.
             **kwargs: Additional keyword arguments. Note: 'insecure_tls' is deprecated in favor of no_check_certificate.
@@ -66,8 +66,8 @@ def __init__(self, host, api_key=None, internal_ticket=None, extra_headers=None,
         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 no_check_certificate:
+            self._session.verify = False
         if client_certificate:
             self._session.cert = client_certificate
 
@@ -527,21 +527,22 @@ def start_fetch_external_groups(self, user_source_type):
         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):
+    def start_fetch_external_users(self, user_source_type, login=None, email=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)
+         - if login or email 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 email: optional - the email 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})
+        future_resp = self._perform_json("GET", "/admin/external-users", params={'userSourceType': user_source_type, 'login': login, 'email': email, 'groupName': group_name})
         return DSSFuture.from_resp(self, future_resp)
 
     def start_provision_users(self, user_source_type, users):
@@ -710,6 +711,38 @@ def get_code_env(self, env_lang, env_name):
         """
         return DSSCodeEnv(self, env_lang, env_name)
 
+    def create_internal_code_env(self, internal_env_type, python_interpreter=None, code_env_version=None):
+        """
+        Create a Python internal code environment, 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
+
+        Example:
+
+        .. code-block:: python
+
+            env_handle = client.create_internal_code_env(internal_env_type="RAG_CODE_ENV", python_interpreter="PYTHON310")
+
+        :param str internal_env_type: the internal env type, can be `DEEP_HUB_IMAGE_CLASSIFICATION_CODE_ENV`, `DEEP_HUB_IMAGE_OBJECT_DETECTION_CODE_ENV`, `PROXY_MODELS_CODE_ENV`, `DATABRICKS_UTILS_CODE_ENV`, `PII_DETECTION_CODE_ENV`, `HUGGINGFACE_LOCAL_CODE_ENV` or `RAG_CODE_ENV`.
+        :param str python_interpreter: Python interpreter version, can be `PYTHON39`, `PYTHON310`, `PYTHON311` or `PYTHON312`. If None, DSS will try to select a supported & available interpreter.
+        :param str code_env_version: Version of the code env. Reserved for future use.
+        :returns: A :class:`dataikuapi.dss.admin.DSSCodeEnv` code env handle
+        """
+        request_params = {
+            'dssInternalCodeEnvType': internal_env_type,
+            'pythonInterpreter': python_interpreter,
+            'codeEnvVersion': code_env_version,
+        }
+
+        response = self._perform_json("POST", "/admin/code-envs/internal-env/create", params=request_params)
+
+        if response is None:
+            raise Exception('Env creation returned no data')
+        if response.get('messages', {}).get('error', False):
+            raise Exception('Env creation failed : %s' % (json.dumps(response.get('messages', {}).get('messages', {}))))
+
+        return DSSCodeEnv(self, "python", response["envName"])
+
     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

dataikuapi/fmclient.py

@@ -84,7 +84,7 @@ def __init__(
             api_key_secret (str): The API key secret for authentication
             tenant_id (str, optional): The tenant ID. Defaults to "main"
             extra_headers (dict, optional): Additional HTTP headers to include in all requests
-            no_check_certificate (bool or str, optional): If True, disables SSL certificate verification.
+            no_check_certificate (bool, optional): If True, disables SSL certificate verification.
                 Defaults to False.
             client_certificate (str or tuple, optional): Path to client certificate file or tuple of 
                 (cert, key) paths for client certificate authentication

dataikuapi/govern/admin.py

@@ -51,10 +51,10 @@ def get_client_as(self):
         if self.client.api_key is not None:
             return GovernClient(self.client.host, self.client.api_key, extra_headers={"X-DKU-ProxyUser": self.login}, no_check_certificate=not self.client._session.verify, client_certificate=self.client._session.cert)
         elif self.client.internal_ticket is not None:
-            verify = self.client._session.verify
-            no_check_certificate = verify if isinstance(verify, str) else not verify
-            return GovernClient(self.client.host, internal_ticket=self.client.internal_ticket,
-                                extra_headers={"X-DKU-ProxyUser": self.login}, no_check_certificate=no_check_certificate, client_certificate=self.client._session.cert)
+            client_as = GovernClient(self.client.host, internal_ticket=self.client.internal_ticket,
+                                extra_headers={"X-DKU-ProxyUser": self.login}, client_certificate=self.client._session.cert)
+            client_as._session.verify = self.client._session.verify
+            return client_as
         else:
             raise ValueError("Don't know how to proxy this client")