genesis-flow 1.0.0__py3-none-any.whl

mlflow/store/artifact/databricks_sdk_artifact_repo.py

@@ -0,0 +1,134 @@
+import importlib.metadata
+import logging
+import posixpath
+from concurrent.futures import Future
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+from packaging.version import Version
+
+from mlflow.entities import FileInfo
+from mlflow.environment_variables import MLFLOW_MULTIPART_UPLOAD_CHUNK_SIZE
+from mlflow.exceptions import MlflowException
+from mlflow.store.artifact.artifact_repo import ArtifactRepository
+
+if TYPE_CHECKING:
+    from databricks.sdk.service.files import FilesAPI
+
+
+def _sdk_supports_large_file_uploads() -> bool:
+    # https://github.com/databricks/databricks-sdk-py/commit/7ca3fb7e8643126b74c9f5779dc01fb20c1741fb
+    return Version(importlib.metadata.version("databricks-sdk")) >= Version("0.45.0")
+
+
+_logger = logging.getLogger(__name__)
+
+
+# TODO: The following artifact repositories should use this class. Migrate them.
+#   - databricks_sdk_models_artifact_repo.py
+class DatabricksSdkArtifactRepository(ArtifactRepository):
+    def __init__(self, artifact_uri: str, tracking_uri: Optional[str] = None) -> None:
+        from databricks.sdk import WorkspaceClient
+        from databricks.sdk.config import Config
+
+        super().__init__(artifact_uri, tracking_uri)
+        supports_large_file_uploads = _sdk_supports_large_file_uploads()
+        wc = WorkspaceClient(
+            config=(
+                Config(enable_experimental_files_api_client=True)
+                if supports_large_file_uploads
+                else None
+            )
+        )
+        if supports_large_file_uploads:
+            # `Config` has a `multipart_upload_min_stream_size` parameter but the constructor
+            # doesn't set it. This is a bug in databricks-sdk.
+            # >>> from databricks.sdk.config import Config
+            # >>> config = Config(multipart_upload_chunk_size=123)
+            # >>> assert config.multipart_upload_chunk_size != 123
+            try:
+                wc.files._config.multipart_upload_chunk_size = (
+                    MLFLOW_MULTIPART_UPLOAD_CHUNK_SIZE.get()
+                )
+            except AttributeError:
+                _logger.debug("Failed to set multipart_upload_chunk_size in Config", exc_info=True)
+        self.wc = wc
+
+    @property
+    def files_api(self) -> "FilesAPI":
+        return self.wc.files
+
+    def _is_dir(self, path: str) -> bool:
+        from databricks.sdk.errors.platform import NotFound
+
+        try:
+            self.files_api.get_directory_metadata(path)
+        except NotFound:
+            return False
+        return True
+
+    def full_path(self, artifact_path: Optional[str]) -> str:
+        return f"{self.artifact_uri}/{artifact_path}" if artifact_path else self.artifact_uri
+
+    def log_artifact(self, local_file: str, artifact_path: Optional[str] = None) -> None:
+        if Path(local_file).stat().st_size > 5 * (1024**3) and not _sdk_supports_large_file_uploads:
+            raise MlflowException.invalid_parameter_value(
+                "Databricks SDK version < 0.41.0 does not support uploading files larger than 5GB. "
+                "Please upgrade the databricks-sdk package to version >= 0.41.0."
+            )
+
+        with open(local_file, "rb") as f:
+            name = Path(local_file).name
+            self.files_api.upload(
+                self.full_path(posixpath.join(artifact_path, name) if artifact_path else name),
+                f,
+                overwrite=True,
+            )
+
+    def log_artifacts(self, local_dir: str, artifact_path: Optional[str] = None) -> None:
+        local_dir = Path(local_dir).resolve()
+        futures: list[Future[None]] = []
+        with self._create_thread_pool() as executor:
+            for f in local_dir.rglob("*"):
+                if not f.is_file():
+                    continue
+
+                paths: list[str] = []
+                if artifact_path:
+                    paths.append(artifact_path)
+                if f.parent != local_dir:
+                    paths.append(str(f.parent.relative_to(local_dir)))
+
+                fut = executor.submit(
+                    self.log_artifact,
+                    local_file=f,
+                    artifact_path=posixpath.join(*paths) if paths else None,
+                )
+                futures.append(fut)
+
+        for fut in futures:
+            fut.result()
+
+    def list_artifacts(self, path: Optional[str] = None) -> list[FileInfo]:
+        dest_path = self.full_path(path)
+        if not self._is_dir(dest_path):
+            return []
+
+        file_infos: list[FileInfo] = []
+        for directory_entry in self.files_api.list_directory_contents(dest_path):
+            relative_path = posixpath.relpath(directory_entry.path, self.artifact_uri)
+            file_infos.append(
+                FileInfo(
+                    path=relative_path,
+                    is_dir=directory_entry.is_directory,
+                    file_size=directory_entry.file_size,
+                )
+            )
+
+        return sorted(file_infos, key=lambda f: f.path)
+
+    def _download_file(self, remote_file_path: str, local_path: str) -> None:
+        download_resp = self.files_api.download(self.full_path(remote_file_path))
+        with open(local_path, "wb") as f:
+            while chunk := download_resp.contents.read(10 * 1024 * 1024):
+                f.write(chunk)

mlflow/store/artifact/databricks_sdk_models_artifact_repo.py

@@ -0,0 +1,97 @@
+import posixpath
+from typing import Optional
+
+from mlflow.entities import FileInfo
+from mlflow.environment_variables import (
+    MLFLOW_MULTIPART_DOWNLOAD_CHUNK_SIZE,
+)
+from mlflow.store.artifact.cloud_artifact_repo import CloudArtifactRepository
+
+
+def _get_databricks_workspace_client():
+    from databricks.sdk import WorkspaceClient
+
+    return WorkspaceClient()
+
+
+class DatabricksSDKModelsArtifactRepository(CloudArtifactRepository):
+    """
+    Stores and retrieves model artifacts via Databricks SDK, agnostic to the underlying cloud
+    that stores the model artifacts.
+    """
+
+    def __init__(self, model_name, model_version):
+        self.model_name = model_name
+        self.model_version = model_version
+        self.model_base_path = f"/Models/{model_name.replace('.', '/')}/{model_version}"
+        self.client = _get_databricks_workspace_client()
+        super().__init__(self.model_base_path)
+
+    def list_artifacts(self, path: Optional[str] = None) -> list[FileInfo]:
+        dest_path = self.model_base_path
+        if path:
+            dest_path = posixpath.join(dest_path, path)
+
+        file_infos = []
+
+        # check if dest_path is file, if so return empty dir
+        if not self._is_dir(dest_path):
+            return file_infos
+
+        resp = self.client.files.list_directory_contents(dest_path)
+        for directory_entry in resp:
+            relative_path = posixpath.relpath(directory_entry.path, self.model_base_path)
+            file_infos.append(
+                FileInfo(
+                    path=relative_path,
+                    is_dir=directory_entry.is_directory,
+                    file_size=directory_entry.file_size,
+                )
+            )
+
+        return sorted(file_infos, key=lambda f: f.path)
+
+    def _is_dir(self, artifact_path):
+        from databricks.sdk.errors.platform import NotFound
+
+        try:
+            self.client.files.get_directory_metadata(artifact_path)
+        except NotFound:
+            return False
+        return True
+
+    def _upload_to_cloud(self, cloud_credential_info, src_file_path, artifact_file_path=None):
+        dest_path = self.model_base_path
+        if artifact_file_path:
+            dest_path = posixpath.join(dest_path, artifact_file_path)
+
+        with open(src_file_path, "rb") as f:
+            self.client.files.upload(dest_path, f, overwrite=True)
+
+    def log_artifact(self, local_file, artifact_path=None):
+        self._upload_to_cloud(
+            cloud_credential_info=None,
+            src_file_path=local_file,
+            artifact_file_path=artifact_path,
+        )
+
+    def _download_from_cloud(self, remote_file_path, local_path):
+        dest_path = self.model_base_path
+        if remote_file_path:
+            dest_path = posixpath.join(dest_path, remote_file_path)
+
+        resp = self.client.files.download(dest_path)
+        contents = resp.contents
+        chunk_size = MLFLOW_MULTIPART_DOWNLOAD_CHUNK_SIZE.get()
+
+        with open(local_path, "wb") as f:
+            while chunk := contents.read(chunk_size):
+                f.write(chunk)
+
+    def _get_write_credential_infos(self, remote_file_paths):
+        # Databricks sdk based model download/upload don't need any extra credentials
+        return [None] * len(remote_file_paths)
+
+    def _get_read_credential_infos(self, remote_file_paths):
+        # Databricks sdk based model download/upload don't need any extra credentials
+        return [None] * len(remote_file_paths)

mlflow/store/artifact/dbfs_artifact_repo.py

@@ -0,0 +1,240 @@
+import json
+import os
+import posixpath
+from typing import Optional
+
+import mlflow.utils.databricks_utils
+from mlflow.entities import FileInfo
+from mlflow.environment_variables import MLFLOW_ENABLE_DBFS_FUSE_ARTIFACT_REPO
+from mlflow.exceptions import MlflowException
+from mlflow.protos.databricks_pb2 import INVALID_PARAMETER_VALUE
+from mlflow.store.artifact.artifact_repo import ArtifactRepository
+from mlflow.store.artifact.databricks_artifact_repo import DatabricksArtifactRepository
+from mlflow.store.artifact.databricks_logged_model_artifact_repo import (
+    DatabricksLoggedModelArtifactRepository,
+)
+from mlflow.store.artifact.local_artifact_repo import LocalArtifactRepository
+from mlflow.store.tracking.rest_store import RestStore
+from mlflow.tracking._tracking_service import utils
+from mlflow.utils.databricks_utils import get_databricks_host_creds
+from mlflow.utils.file_utils import relative_path_to_artifact_path
+from mlflow.utils.rest_utils import (
+    RESOURCE_NON_EXISTENT,
+    http_request,
+    http_request_safe,
+)
+from mlflow.utils.string_utils import strip_prefix
+from mlflow.utils.uri import (
+    get_databricks_profile_uri_from_artifact_uri,
+    is_databricks_acled_artifacts_uri,
+    is_databricks_model_registry_artifacts_uri,
+    is_valid_dbfs_uri,
+    remove_databricks_profile_info_from_artifact_uri,
+    strip_scheme,
+)
+
+# The following constants are defined as @developer_stable
+LIST_API_ENDPOINT = "/api/2.0/dbfs/list"
+GET_STATUS_ENDPOINT = "/api/2.0/dbfs/get-status"
+DOWNLOAD_CHUNK_SIZE = 1024
+
+
+class DbfsRestArtifactRepository(ArtifactRepository):
+    """
+    Stores artifacts on DBFS using the DBFS REST API.
+
+    This repository is used with URIs of the form ``dbfs:/<path>``. The repository can only be used
+    together with the RestStore.
+    """
+
+    def __init__(self, artifact_uri: str, tracking_uri: Optional[str] = None) -> None:
+        if not is_valid_dbfs_uri(artifact_uri):
+            raise MlflowException(
+                message="DBFS URI must be of the form dbfs:/<path> or "
+                + "dbfs://profile@databricks/<path>",
+                error_code=INVALID_PARAMETER_VALUE,
+            )
+
+        # The dbfs:/ path ultimately used for artifact operations should not contain the
+        # Databricks profile info, so strip it before setting ``artifact_uri``.
+        super().__init__(
+            remove_databricks_profile_info_from_artifact_uri(artifact_uri), tracking_uri
+        )
+
+        databricks_profile_uri = get_databricks_profile_uri_from_artifact_uri(artifact_uri)
+        if databricks_profile_uri:
+            hostcreds_from_uri = get_databricks_host_creds(databricks_profile_uri)
+            self.get_host_creds = lambda: hostcreds_from_uri
+        else:
+            self.get_host_creds = _get_host_creds_from_default_store()
+
+    def _databricks_api_request(self, endpoint, method, **kwargs):
+        host_creds = self.get_host_creds()
+        return http_request_safe(host_creds=host_creds, endpoint=endpoint, method=method, **kwargs)
+
+    def _dbfs_list_api(self, json):
+        host_creds = self.get_host_creds()
+        return http_request(
+            host_creds=host_creds, endpoint=LIST_API_ENDPOINT, method="GET", params=json
+        )
+
+    def _dbfs_download(self, output_path, endpoint):
+        with open(output_path, "wb") as f:
+            response = self._databricks_api_request(endpoint=endpoint, method="GET", stream=True)
+            try:
+                for content in response.iter_content(chunk_size=DOWNLOAD_CHUNK_SIZE):
+                    f.write(content)
+            finally:
+                response.close()
+
+    def _is_directory(self, artifact_path):
+        dbfs_path = self._get_dbfs_path(artifact_path) if artifact_path else self._get_dbfs_path("")
+        return self._dbfs_is_dir(dbfs_path)
+
+    def _dbfs_is_dir(self, dbfs_path):
+        response = self._databricks_api_request(
+            endpoint=GET_STATUS_ENDPOINT, method="GET", params={"path": dbfs_path}
+        )
+        json_response = json.loads(response.text)
+        try:
+            return json_response["is_dir"]
+        except KeyError:
+            raise MlflowException(f"DBFS path {dbfs_path} does not exist")
+
+    def _get_dbfs_path(self, artifact_path):
+        return "/{}/{}".format(
+            strip_scheme(self.artifact_uri).lstrip("/"),
+            artifact_path.lstrip("/"),
+        )
+
+    def _get_dbfs_endpoint(self, artifact_path):
+        return f"/dbfs{self._get_dbfs_path(artifact_path)}"
+
+    def log_artifact(self, local_file, artifact_path=None):
+        basename = os.path.basename(local_file)
+        if artifact_path:
+            http_endpoint = self._get_dbfs_endpoint(posixpath.join(artifact_path, basename))
+        else:
+            http_endpoint = self._get_dbfs_endpoint(basename)
+        if os.stat(local_file).st_size == 0:
+            # The API frontend doesn't like it when we post empty files to it using
+            # `requests.request`, potentially due to the bug described in
+            # https://github.com/requests/requests/issues/4215
+            self._databricks_api_request(
+                endpoint=http_endpoint, method="POST", data="", allow_redirects=False
+            )
+        else:
+            with open(local_file, "rb") as f:
+                self._databricks_api_request(
+                    endpoint=http_endpoint, method="POST", data=f, allow_redirects=False
+                )
+
+    def log_artifacts(self, local_dir, artifact_path=None):
+        artifact_path = artifact_path or ""
+        for dirpath, _, filenames in os.walk(local_dir):
+            artifact_subdir = artifact_path
+            if dirpath != local_dir:
+                rel_path = os.path.relpath(dirpath, local_dir)
+                rel_path = relative_path_to_artifact_path(rel_path)
+                artifact_subdir = posixpath.join(artifact_path, rel_path)
+            for name in filenames:
+                file_path = os.path.join(dirpath, name)
+                self.log_artifact(file_path, artifact_subdir)
+
+    def list_artifacts(self, path: Optional[str] = None) -> list[FileInfo]:
+        dbfs_path = self._get_dbfs_path(path) if path else self._get_dbfs_path("")
+        dbfs_list_json = {"path": dbfs_path}
+        response = self._dbfs_list_api(dbfs_list_json)
+        try:
+            json_response = json.loads(response.text)
+        except ValueError:
+            raise MlflowException(
+                f"API request to list files under DBFS path {dbfs_path} failed with "
+                f"status code {response.status_code}. Response body: {response.text}"
+            )
+        # /api/2.0/dbfs/list will not have the 'files' key in the response for empty directories.
+        infos = []
+        artifact_prefix = strip_prefix(self.artifact_uri, "dbfs:")
+        if json_response.get("error_code", None) == RESOURCE_NON_EXISTENT:
+            return []
+        dbfs_files = json_response.get("files", [])
+        for dbfs_file in dbfs_files:
+            stripped_path = strip_prefix(dbfs_file["path"], artifact_prefix + "/")
+            # If `path` is a file, the DBFS list API returns a single list element with the
+            # same name as `path`. The list_artifacts API expects us to return an empty list in this
+            # case, so we do so here.
+            if stripped_path == path:
+                return []
+            is_dir = dbfs_file["is_dir"]
+            artifact_size = None if is_dir else dbfs_file["file_size"]
+            infos.append(FileInfo(stripped_path, is_dir, artifact_size))
+        return sorted(infos, key=lambda f: f.path)
+
+    def _download_file(self, remote_file_path, local_path):
+        self._dbfs_download(
+            output_path=local_path, endpoint=self._get_dbfs_endpoint(remote_file_path)
+        )
+
+    def delete_artifacts(self, artifact_path=None):
+        raise MlflowException("Not implemented yet")
+
+
+def _get_host_creds_from_default_store():
+    store = utils._get_store()
+    if not isinstance(store, RestStore):
+        raise MlflowException(
+            "Failed to get credentials for DBFS; they are read from the "
+            + "Databricks CLI credentials or MLFLOW_TRACKING* environment "
+            + "variables."
+        )
+    return store.get_host_creds
+
+
+def dbfs_artifact_repo_factory(artifact_uri: str, tracking_uri: Optional[str] = None):
+    """
+    Returns an ArtifactRepository subclass for storing artifacts on DBFS.
+
+    This factory method is used with URIs of the form ``dbfs:/<path>``. DBFS-backed artifact
+    storage can only be used together with the RestStore.
+
+    In the special case where the URI is of the form
+    `dbfs:/databricks/mlflow-tracking/<Exp-ID>/<Run-ID>/<path>',
+    a DatabricksArtifactRepository is returned. This is capable of storing access controlled
+    artifacts.
+
+    Args:
+        artifact_uri: DBFS root artifact URI.
+        tracking_uri: The tracking URI.
+
+    Returns:
+        Subclass of ArtifactRepository capable of storing artifacts on DBFS.
+    """
+    if not is_valid_dbfs_uri(artifact_uri):
+        raise MlflowException(
+            "DBFS URI must be of the form dbfs:/<path> or "
+            + "dbfs://profile@databricks/<path>, but received "
+            + artifact_uri
+        )
+
+    cleaned_artifact_uri = artifact_uri.rstrip("/")
+    db_profile_uri = get_databricks_profile_uri_from_artifact_uri(cleaned_artifact_uri)
+    if is_databricks_acled_artifacts_uri(artifact_uri):
+        if DatabricksLoggedModelArtifactRepository.is_logged_model_uri(artifact_uri):
+            return DatabricksLoggedModelArtifactRepository(cleaned_artifact_uri, tracking_uri)
+        return DatabricksArtifactRepository(cleaned_artifact_uri, tracking_uri)
+    elif (
+        mlflow.utils.databricks_utils.is_dbfs_fuse_available()
+        and MLFLOW_ENABLE_DBFS_FUSE_ARTIFACT_REPO.get()
+        and not is_databricks_model_registry_artifacts_uri(artifact_uri)
+        and (db_profile_uri is None or db_profile_uri == "databricks")
+    ):
+        # If the DBFS FUSE mount is available, write artifacts directly to
+        # /dbfs/... using local filesystem APIs.
+        # Note: it is possible for a named Databricks profile to point to the current workspace,
+        # but we're going to avoid doing a complex check and assume users will use `databricks`
+        # to mean the current workspace. Using `DbfsRestArtifactRepository` to access the current
+        # workspace's DBFS should still work; it just may be slower.
+        final_artifact_uri = remove_databricks_profile_info_from_artifact_uri(cleaned_artifact_uri)
+        file_uri = "file:///dbfs/{}".format(strip_prefix(final_artifact_uri, "dbfs:/"))
+        return LocalArtifactRepository(file_uri, tracking_uri)
+    return DbfsRestArtifactRepository(cleaned_artifact_uri, tracking_uri)

mlflow/store/artifact/ftp_artifact_repo.py

@@ -0,0 +1,132 @@
+import ftplib
+import os
+import posixpath
+import urllib.parse
+from contextlib import contextmanager
+from ftplib import FTP
+from typing import Optional
+from urllib.parse import unquote
+
+from mlflow.entities.file_info import FileInfo
+from mlflow.exceptions import MlflowException
+from mlflow.store.artifact.artifact_repo import ArtifactRepository
+from mlflow.utils.file_utils import relative_path_to_artifact_path
+
+
+class FTPArtifactRepository(ArtifactRepository):
+    """Stores artifacts as files in a remote directory, via ftp."""
+
+    def __init__(self, artifact_uri: str, tracking_uri: Optional[str] = None) -> None:
+        super().__init__(artifact_uri, tracking_uri)
+        parsed = urllib.parse.urlparse(artifact_uri)
+        self.config = {
+            "host": parsed.hostname,
+            "port": 21 if parsed.port is None else parsed.port,
+            "username": parsed.username,
+            "password": parsed.password,
+        }
+        self.path = parsed.path or "/"
+
+        if self.config["host"] is None:
+            self.config["host"] = "localhost"
+        if self.config["password"] is None:
+            self.config["password"] = ""
+        else:
+            self.config["password"] = unquote(parsed.password)
+
+    @contextmanager
+    def get_ftp_client(self):
+        ftp = FTP()
+        ftp.connect(self.config["host"], self.config["port"])
+        ftp.login(self.config["username"], self.config["password"])
+        yield ftp
+        ftp.close()
+
+    @staticmethod
+    def _is_dir(ftp, full_file_path):
+        try:
+            ftp.cwd(full_file_path)
+            return True
+        except ftplib.error_perm:
+            return False
+
+    @staticmethod
+    def _mkdir(ftp, artifact_dir):
+        try:
+            if not FTPArtifactRepository._is_dir(ftp, artifact_dir):
+                ftp.mkd(artifact_dir)
+        except ftplib.error_perm:
+            head, _ = posixpath.split(artifact_dir)
+            FTPArtifactRepository._mkdir(ftp, head)
+            FTPArtifactRepository._mkdir(ftp, artifact_dir)
+
+    @staticmethod
+    def _size(ftp, full_file_path):
+        ftp.voidcmd("TYPE I")
+        size = ftp.size(full_file_path)
+        ftp.voidcmd("TYPE A")
+        return size
+
+    def log_artifact(self, local_file, artifact_path=None):
+        with self.get_ftp_client() as ftp:
+            artifact_dir = posixpath.join(self.path, artifact_path) if artifact_path else self.path
+            self._mkdir(ftp, artifact_dir)
+            with open(local_file, "rb") as f:
+                ftp.cwd(artifact_dir)
+                ftp.storbinary("STOR " + os.path.basename(local_file), f)
+
+    def log_artifacts(self, local_dir, artifact_path=None):
+        dest_path = posixpath.join(self.path, artifact_path) if artifact_path else self.path
+
+        local_dir = os.path.abspath(local_dir)
+        for root, _, filenames in os.walk(local_dir):
+            upload_path = dest_path
+            if root != local_dir:
+                rel_path = os.path.relpath(root, local_dir)
+                rel_upload_path = relative_path_to_artifact_path(rel_path)
+                upload_path = posixpath.join(dest_path, rel_upload_path)
+            if not filenames:
+                with self.get_ftp_client() as ftp:
+                    self._mkdir(ftp, upload_path)
+            for f in filenames:
+                if os.path.isfile(os.path.join(root, f)):
+                    self.log_artifact(os.path.join(root, f), upload_path)
+
+    def _is_directory(self, artifact_path):
+        artifact_dir = self.path
+        list_dir = posixpath.join(artifact_dir, artifact_path) if artifact_path else artifact_dir
+        with self.get_ftp_client() as ftp:
+            return self._is_dir(ftp, list_dir)
+
+    def list_artifacts(self, path=None):
+        with self.get_ftp_client() as ftp:
+            artifact_dir = self.path
+            list_dir = posixpath.join(artifact_dir, path) if path else artifact_dir
+            if not self._is_dir(ftp, list_dir):
+                return []
+            artifact_files = ftp.nlst(list_dir)
+            # Make sure artifact_files is a list of file names because ftp.nlst
+            # may return absolute paths.
+            artifact_files = [os.path.basename(f) for f in artifact_files]
+            artifact_files = list(filter(lambda x: x != "." and x != "..", artifact_files))
+            infos = []
+            for file_name in artifact_files:
+                file_path = file_name if path is None else posixpath.join(path, file_name)
+                full_file_path = posixpath.join(list_dir, file_name)
+                if self._is_dir(ftp, full_file_path):
+                    infos.append(FileInfo(file_path, True, None))
+                else:
+                    size = self._size(ftp, full_file_path)
+                    infos.append(FileInfo(file_path, False, size))
+        return infos
+
+    def _download_file(self, remote_file_path, local_path):
+        remote_full_path = (
+            posixpath.join(self.path, remote_file_path) if remote_file_path else self.path
+        )
+        with self.get_ftp_client() as ftp:
+            with open(local_path, "wb") as f:
+                ftp.retrbinary("RETR " + remote_full_path, f.write)
+
+    def delete_artifacts(self, artifact_path=None):
+        raise MlflowException("Not implemented yet")