mlrun 1.3.2rc1__py3-none-any.whl → 1.3.2rc2__py3-none-any.whl

mlrun/platforms/iguazio.py

@@ -403,37 +403,6 @@ class OutputStream:
             )
 
 
-class HTTPOutputStream:
-    """HTTP output source that usually used for CE mode and debugging process"""
-
-    def __init__(self, stream_path: str):
-        self._stream_path = stream_path
-
-    def push(self, data):
-        def dump_record(rec):
-            if isinstance(rec, bytes):
-                return rec
-
-            if not isinstance(rec, str):
-                rec = dict_to_json(rec)
-
-            return rec.encode("UTF-8")
-
-        if not isinstance(data, list):
-            data = [data]
-
-        for record in data:
-
-            # Convert the new record to the required format
-            serialized_record = dump_record(record)
-            response = requests.post(self._stream_path, data=serialized_record)
-            if not response:
-                raise mlrun.errors.MLRunInvalidArgumentError(
-                    f"API call failed push a new record through {self._stream_path}"
-                    f"status {response.status_code}: {response.reason}"
-                )
-
-
 class KafkaOutputStream:
     def __init__(
         self,
@@ -681,8 +650,6 @@ def parse_path(url, suffix="/"):
             )
         endpoint = f"{prefix}://{parsed_url.netloc}"
     else:
-        # no netloc is mainly when using v3io (v3io:///) and expecting the url to be resolved automatically from env or
-        # config
         endpoint = None
     return endpoint, parsed_url.path.strip("/") + suffix
 

mlrun/projects/project.py

@@ -36,7 +36,6 @@ import yaml
 import mlrun.api.schemas
 import mlrun.db
 import mlrun.errors
-import mlrun.model_monitoring.constants as model_monitoring_constants
 import mlrun.utils.regex
 from mlrun.runtimes import RuntimeKinds
 
@@ -58,6 +57,7 @@ from ..utils import (
 )
 from ..utils.clones import clone_git, clone_tgz, clone_zip, get_repo_url
 from ..utils.helpers import ensure_git_branch, resolve_git_reference_from_source
+from ..utils.model_monitoring import set_project_model_monitoring_credentials
 from ..utils.notifications import CustomNotificationPusher, NotificationTypes
 from .operations import (
     BuildStatus,
@@ -2105,43 +2105,15 @@ class MlrunProject(ModelObj):
                 mlrun.get_dataitem(filepath).upload(tmp_path)
                 remove(tmp_path)
 
-    def set_model_monitoring_credentials(
-        self,
-        access_key: str = None,
-        endpoint_store_connection: str = None,
-        stream_path: str = None,
-    ):
+    def set_model_monitoring_credentials(self, access_key: str):
         """Set the credentials that will be used by the project's model monitoring
         infrastructure functions.
+        The supplied credentials must have data access
 
-        :param access_key:                Model Monitoring access key for managing user permissions
-        :param endpoint_store_connection: Endpoint store connection string
-        :param stream_path:               Path to the model monitoring stream
+        :param access_key: Model Monitoring access key for managing user permissions.
         """
-
-        secrets_dict = {}
-        if access_key:
-            secrets_dict[
-                model_monitoring_constants.ProjectSecretKeys.ACCESS_KEY
-            ] = access_key
-
-        if endpoint_store_connection:
-            secrets_dict[
-                model_monitoring_constants.ProjectSecretKeys.ENDPOINT_STORE_CONNECTION
-            ] = endpoint_store_connection
-
-        if stream_path:
-            if stream_path.startswith("kafka://") and "?topic" in stream_path:
-                raise mlrun.errors.MLRunInvalidArgumentError(
-                    "Custom kafka topic is not allowed"
-                )
-            secrets_dict[
-                model_monitoring_constants.ProjectSecretKeys.STREAM_PATH
-            ] = stream_path
-
-        self.set_secrets(
-            secrets=secrets_dict,
-            provider=mlrun.api.schemas.SecretProviderName.kubernetes,
+        set_project_model_monitoring_credentials(
+            access_key=access_key, project=self.metadata.name
         )
 
     def run_function(
@@ -2608,6 +2580,72 @@ def _init_function_from_obj(func, project, name=None):
     return name or func.metadata.name, func
 
 
+def _init_function_from_dict_legacy(f, project):
+    name = f.get("name", "")
+    url = f.get("url", "")
+    kind = f.get("kind", "")
+    image = f.get("image", None)
+    with_repo = f.get("with_repo", False)
+
+    if with_repo and not project.source:
+        raise ValueError("project source must be specified when cloning context")
+
+    in_context = False
+    if not url and "spec" not in f:
+        raise ValueError("function missing a url or a spec")
+    # We are not using the project method to obtain an absolute path here,
+    # because legacy projects are built differently, and we cannot rely on them to have a spec
+    if url and "://" not in url:
+        if project.context and not url.startswith("/"):
+            url = path.join(project.context, url)
+            in_context = True
+        if not path.isfile(url):
+            raise OSError(f"{url} not found")
+
+    if "spec" in f:
+        func = new_function(name, runtime=f["spec"])
+    elif is_yaml_path(url) or url.startswith("db://") or url.startswith("hub://"):
+        func = import_function(url)
+        if image:
+            func.spec.image = image
+    elif url.endswith(".ipynb"):
+        func = code_to_function(name, filename=url, image=image, kind=kind)
+    elif url.endswith(".py"):
+        if not image:
+            raise ValueError(
+                "image must be provided with py code files, "
+                "use function object for more control/settings"
+            )
+        if in_context and with_repo:
+            func = new_function(name, command=url, image=image, kind=kind or "job")
+        else:
+            func = code_to_function(name, filename=url, image=image, kind=kind or "job")
+    else:
+        raise ValueError(f"unsupported function url {url} or no spec")
+
+    if with_repo:
+        func.spec.build.source = "./"
+
+    return _init_function_from_obj_legacy(func, project, name)
+
+
+def _init_function_from_obj_legacy(func, project, name=None):
+    build = func.spec.build
+    if project.origin_url:
+        origin = project.origin_url
+        try:
+            if project.repo:
+                origin += "#" + project.repo.head.commit.hexsha
+        except Exception:
+            pass
+        build.code_origin = origin
+    if project.name:
+        func.metadata.project = project.name
+    if project.tag:
+        func.metadata.tag = project.tag
+    return name or func.metadata.name, func
+
+
 def _has_module(handler, kind):
     if not handler:
         return False

mlrun/runtimes/base.py

@@ -90,7 +90,6 @@ spec_fields = [
     "pythonpath",
     "disable_auto_mount",
     "allow_empty_resources",
-    "clone_target_dir",
 ]
 
 
@@ -131,7 +130,6 @@ class FunctionSpec(ModelObj):
         default_handler=None,
         pythonpath=None,
         disable_auto_mount=False,
-        clone_target_dir=None,
     ):
 
         self.command = command or ""
@@ -150,9 +148,6 @@ class FunctionSpec(ModelObj):
         self.entry_points = entry_points or {}
         self.disable_auto_mount = disable_auto_mount
         self.allow_empty_resources = None
-        # the build.source is cloned/extracted to the specified clone_target_dir
-        # if a relative path is specified, it will be enriched with a temp dir path
-        self.clone_target_dir = clone_target_dir or ""
 
     @property
     def build(self) -> ImageBuilder:

mlrun/runtimes/daskjob.py

@@ -106,7 +106,6 @@ class DaskSpec(KubeResourceSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
-        clone_target_dir=None,
     ):
 
         super().__init__(
@@ -136,7 +135,6 @@ class DaskSpec(KubeResourceSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
-            clone_target_dir=clone_target_dir,
         )
         self.args = args
 

mlrun/runtimes/function.py

@@ -141,8 +141,6 @@ class NuclioSpec(KubeResourceSpec):
         "function_handler",
         "nuclio_runtime",
         "base_image_pull",
-        "service_type",
-        "add_templated_ingress_host_mode",
     ]
 
     def __init__(
@@ -181,9 +179,6 @@ class NuclioSpec(KubeResourceSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
-        service_type=None,
-        add_templated_ingress_host_mode=None,
-        clone_target_dir=None,
     ):
 
         super().__init__(
@@ -213,7 +208,6 @@ class NuclioSpec(KubeResourceSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
-            clone_target_dir=clone_target_dir,
         )
 
         self.base_spec = base_spec or {}
@@ -224,8 +218,6 @@ class NuclioSpec(KubeResourceSpec):
         self.nuclio_runtime = None
         self.no_cache = no_cache
         self.readiness_timeout = readiness_timeout
-        self.service_type = service_type
-        self.add_templated_ingress_host_mode = add_templated_ingress_host_mode
 
         self.min_replicas = min_replicas or 1
         self.max_replicas = max_replicas or 4
@@ -702,22 +694,6 @@ class RemoteRuntime(KubeResource):
         """k8s priority class"""
         super().with_priority_class(name)
 
-    def with_service_type(
-        self, service_type: str, add_templated_ingress_host_mode: str = None
-    ):
-        """
-        Enables to control the service type of the pod and the addition of templated ingress host
-
-        :param service_type:                      service type (ClusterIP, NodePort), defaults to
-                                                  mlrun.mlconf.httpdb.nuclio.service_type
-        :param add_templated_ingress_host_mode:   add templated ingress host mode (never, always, onClusterIP),
-                                                  see mlrun.mlconf.httpdb.nuclio.add_templated_ingress_host_mode
-                                                  for the default and more information
-
-        """
-        self.spec.service_type = service_type
-        self.spec.add_templated_ingress_host_mode = add_templated_ingress_host_mode
-
     def _get_state(
         self,
         dashboard="",
@@ -1234,9 +1210,8 @@ def deploy_nuclio_function(
     # if mode allows it, enrich function http trigger with an ingress
     enrich_function_with_ingress(
         function_config,
-        function.spec.add_templated_ingress_host_mode
-        or mlconf.httpdb.nuclio.add_templated_ingress_host_mode,
-        function.spec.service_type or mlconf.httpdb.nuclio.default_service_type,
+        mlconf.httpdb.nuclio.add_templated_ingress_host_mode,
+        mlconf.httpdb.nuclio.default_service_type,
     )
 
     try:
@@ -1402,8 +1377,7 @@ def compile_function_config(
 
     # In Nuclio >= 1.6.x default serviceType has changed to "ClusterIP".
     nuclio_spec.set_config(
-        "spec.serviceType",
-        function.spec.service_type or mlconf.httpdb.nuclio.default_service_type,
+        "spec.serviceType", mlconf.httpdb.nuclio.default_service_type
     )
     if function.spec.readiness_timeout:
         nuclio_spec.set_config(

mlrun/runtimes/kubejob.py

@@ -58,17 +58,16 @@ class KubejobRuntime(KubeResource):
         return False
 
     def with_source_archive(
-        self, source, workdir=None, handler=None, pull_at_runtime=True, target_dir=None
+        self, source, workdir=None, handler=None, pull_at_runtime=True
     ):
         """load the code from git/tar/zip archive at runtime or build
 
-        :param source:          valid path to git, zip, or tar file, e.g.
-                                git://github.com/mlrun/something.git
-                                http://some/url/file.zip
-        :param handler:         default function handler
-        :param workdir:         working dir relative to the archive root (e.g. './subdir') or absolute to the image root
+        :param source:     valid path to git, zip, or tar file, e.g.
+                           git://github.com/mlrun/something.git
+                           http://some/url/file.zip
+        :param handler: default function handler
+        :param workdir: working dir relative to the archive root or absolute (e.g. './subdir')
         :param pull_at_runtime: load the archive into the container at job runtime vs on build/deploy
-        :param target_dir:      target dir on runtime pod or repo clone / archive extraction
         """
         if source.endswith(".zip") and not pull_at_runtime:
             logger.warn(
@@ -80,9 +79,6 @@ class KubejobRuntime(KubeResource):
             self.spec.default_handler = handler
         if workdir:
             self.spec.workdir = workdir
-        if target_dir:
-            self.spec.clone_target_dir = target_dir
-
         self.spec.build.load_source_on_run = pull_at_runtime
         if (
             self.spec.build.base_image
@@ -90,7 +86,7 @@ class KubejobRuntime(KubeResource):
             and pull_at_runtime
             and not self.spec.image
         ):
-            # if we load source from repo and don't need a full build use the base_image as the image
+            # if we load source from repo and dont need a full build use the base_image as the image
             self.spec.image = self.spec.build.base_image
         elif not pull_at_runtime:
             # clear the image so build will not be skipped
@@ -227,8 +223,6 @@ class KubejobRuntime(KubeResource):
             self.spec.build.base_image = self.spec.build.base_image or get_in(
                 data, "data.spec.build.base_image"
             )
-            # get the clone target dir in case it was enriched due to loading source
-            self.spec.clone_target_dir = get_in(data, "data.spec.clone_target_dir")
             ready = data.get("ready", False)
             if not ready:
                 logger.info(
@@ -350,7 +344,14 @@ class KubejobRuntime(KubeResource):
         new_meta = self._get_meta(runobj)
 
         self._add_secrets_to_spec_before_running(runobj)
-        workdir = self._resolve_workdir()
+        workdir = self.spec.workdir
+        if workdir:
+            if self.spec.build.source and self.spec.build.load_source_on_run:
+                # workdir will be set AFTER the clone
+                workdir = None
+            elif not workdir.startswith("/"):
+                # relative path mapped to real path in the job pod
+                workdir = os.path.join("/mlrun", workdir)
 
         pod_spec = func_to_pod(
             self.full_image_path(
@@ -384,31 +385,6 @@ class KubejobRuntime(KubeResource):
 
         return None
 
-    def _resolve_workdir(self):
-        """
-        The workdir is relative to the source root, if the source is not loaded on run then the workdir
-        is relative to the clone target dir (where the source was copied to).
-        Otherwise, if the source is loaded on run, the workdir is resolved on the run as well.
-        If the workdir is absolute, keep it as is.
-        """
-        workdir = self.spec.workdir
-        if self.spec.build.source and self.spec.build.load_source_on_run:
-            # workdir will be set AFTER the clone which is done in the pre-run of local runtime
-            return None
-
-        if workdir and os.path.isabs(workdir):
-            return workdir
-
-        if self.spec.clone_target_dir:
-            workdir = workdir or ""
-            if workdir.startswith("./"):
-                # TODO: use 'removeprefix' when we drop python 3.7 support
-                # workdir.removeprefix("./")
-                workdir = workdir[2:]
-            return os.path.join(self.spec.clone_target_dir, workdir)
-
-        return workdir
-
 
 def func_to_pod(image, runtime, extra_env, command, args, workdir):
     container = client.V1Container(

mlrun/runtimes/local.py

@@ -41,7 +41,7 @@ from ..execution import MLClientCtx
 from ..model import RunObject
 from ..utils import get_handler_extended, get_in, logger, set_paths
 from ..utils.clones import extract_source
-from .base import BaseRuntime
+from .base import BaseRuntime, FunctionSpec, spec_fields
 from .kubejob import KubejobRuntime
 from .remotesparkjob import RemoteSparkRuntime
 from .utils import RunError, global_context, log_std
@@ -172,10 +172,48 @@ class HandlerRuntime(BaseRuntime, ParallelRunner):
         return context.to_dict()
 
 
+class LocalFunctionSpec(FunctionSpec):
+    _dict_fields = spec_fields + ["clone_target_dir"]
+
+    def __init__(
+        self,
+        command=None,
+        args=None,
+        mode=None,
+        default_handler=None,
+        pythonpath=None,
+        entry_points=None,
+        description=None,
+        workdir=None,
+        build=None,
+        clone_target_dir=None,
+    ):
+        super().__init__(
+            command=command,
+            args=args,
+            mode=mode,
+            build=build,
+            entry_points=entry_points,
+            description=description,
+            workdir=workdir,
+            default_handler=default_handler,
+            pythonpath=pythonpath,
+        )
+        self.clone_target_dir = clone_target_dir
+
+
 class LocalRuntime(BaseRuntime, ParallelRunner):
     kind = "local"
     _is_remote = False
 
+    @property
+    def spec(self) -> LocalFunctionSpec:
+        return self._spec
+
+    @spec.setter
+    def spec(self, spec):
+        self._spec = self._verify_dict(spec, "spec", LocalFunctionSpec)
+
     def to_job(self, image=""):
         struct = self.to_dict()
         obj = KubejobRuntime.from_dict(struct)
@@ -186,12 +224,12 @@ class LocalRuntime(BaseRuntime, ParallelRunner):
     def with_source_archive(self, source, workdir=None, handler=None, target_dir=None):
         """load the code from git/tar/zip archive at runtime or build
 
-        :param source:      valid path to git, zip, or tar file, e.g.
-                            git://github.com/mlrun/something.git
-                            http://some/url/file.zip
-        :param handler:     default function handler
-        :param workdir:     working dir relative to the archive root (e.g. './subdir') or absolute
-        :param target_dir:  local target dir for repo clone (by default its <current-dir>/code)
+        :param source:     valid path to git, zip, or tar file, e.g.
+                           git://github.com/mlrun/something.git
+                           http://some/url/file.zip
+        :param handler: default function handler
+        :param workdir: working dir relative to the archive root or absolute (e.g. './subdir')
+        :param target_dir: local target dir for repo clone (by default its <current-dir>/code)
         """
         self.spec.build.source = source
         self.spec.build.load_source_on_run = True

mlrun/runtimes/mpijob/abstract.py

@@ -60,7 +60,6 @@ class MPIResourceSpec(KubeResourceSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
-        clone_target_dir=None,
     ):
         super().__init__(
             command=command,
@@ -89,7 +88,6 @@ class MPIResourceSpec(KubeResourceSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
-            clone_target_dir=clone_target_dir,
         )
         self.mpi_args = mpi_args or [
             "-x",

mlrun/runtimes/mpijob/v1.py

@@ -62,7 +62,6 @@ class MPIV1ResourceSpec(MPIResourceSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
-        clone_target_dir=None,
     ):
         super().__init__(
             command=command,
@@ -92,7 +91,6 @@ class MPIV1ResourceSpec(MPIResourceSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
-            clone_target_dir=clone_target_dir,
         )
         self.clean_pod_policy = clean_pod_policy or MPIJobV1CleanPodPolicies.default()
 

mlrun/runtimes/pod.py

@@ -135,7 +135,6 @@ class KubeResourceSpec(FunctionSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
-        clone_target_dir=None,
     ):
         super().__init__(
             command=command,
@@ -149,7 +148,6 @@ class KubeResourceSpec(FunctionSpec):
             default_handler=default_handler,
             pythonpath=pythonpath,
             disable_auto_mount=disable_auto_mount,
-            clone_target_dir=clone_target_dir,
         )
         self._volumes = {}
         self._volume_mounts = {}

mlrun/runtimes/remotesparkjob.py

@@ -58,7 +58,6 @@ class RemoteSparkSpec(KubeResourceSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
-        clone_target_dir=None,
     ):
         super().__init__(
             command=command,
@@ -87,7 +86,6 @@ class RemoteSparkSpec(KubeResourceSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
-            clone_target_dir=clone_target_dir,
         )
         self.provider = provider
 

mlrun/runtimes/serving.py

@@ -141,9 +141,6 @@ class ServingSpec(NuclioSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
-        service_type=None,
-        add_templated_ingress_host_mode=None,
-        clone_target_dir=None,
     ):
 
         super().__init__(
@@ -181,9 +178,6 @@ class ServingSpec(NuclioSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
-            service_type=service_type,
-            add_templated_ingress_host_mode=add_templated_ingress_host_mode,
-            clone_target_dir=clone_target_dir,
         )
 
         self.models = models or {}

mlrun/runtimes/sparkjob/abstract.py

@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import os.path
+
 import typing
 from copy import deepcopy
 from datetime import datetime
@@ -143,7 +143,6 @@ class AbstractSparkJobSpec(KubeResourceSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
-        clone_target_dir=None,
     ):
 
         super().__init__(
@@ -173,7 +172,6 @@ class AbstractSparkJobSpec(KubeResourceSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
-            clone_target_dir=clone_target_dir,
         )
 
         self._driver_resources = self.enrich_resources_with_default_pod_resources(
@@ -365,15 +363,6 @@ class AbstractSparkRuntime(KubejobRuntime):
     def _get_igz_deps(self):
         raise NotImplementedError()
 
-    def _pre_run(self, runobj: RunObject, execution: MLClientCtx):
-        if self.spec.build.source and self.spec.build.load_source_on_run:
-            raise mlrun.errors.MLRunPreconditionFailedError(
-                "Sparkjob does not support loading source code on run, "
-                "use func.with_source_archive(pull_at_runtime=False)"
-            )
-
-        super()._pre_run(runobj, execution)
-
     def _run(self, runobj: RunObject, execution: MLClientCtx):
         self._validate(runobj)
 
@@ -570,11 +559,7 @@ with ctx:
 
         if self.spec.command:
             if "://" not in self.spec.command:
-                workdir = self._resolve_workdir()
-                self.spec.command = "local://" + os.path.join(
-                    workdir or "",
-                    self.spec.command,
-                )
+                self.spec.command = "local://" + self.spec.command
             update_in(job, "spec.mainApplicationFile", self.spec.command)
 
         verify_list_and_update_in(job, "spec.arguments", self.spec.args or [], str)
@@ -804,28 +789,6 @@ with ctx:
             submission_retry_interval,
         )
 
-    def with_source_archive(
-        self, source, workdir=None, handler=None, pull_at_runtime=True, target_dir=None
-    ):
-        """load the code from git/tar/zip archive at runtime or build
-
-        :param source:          valid path to git, zip, or tar file, e.g.
-                                git://github.com/mlrun/something.git
-                                http://some/url/file.zip
-        :param handler:         default function handler
-        :param workdir:         working dir relative to the archive root (e.g. './subdir') or absolute to the image root
-        :param pull_at_runtime: not supported for spark runtime, must be False
-        :param target_dir:      target dir on runtime pod for repo clone / archive extraction
-        """
-        if pull_at_runtime:
-            raise mlrun.errors.MLRunInvalidArgumentError(
-                "pull_at_runtime is not supported for spark runtime, use pull_at_runtime=False"
-            )
-
-        super().with_source_archive(
-            source, workdir, handler, pull_at_runtime, target_dir
-        )
-
     def get_pods(self, name=None, namespace=None, driver=False):
         k8s = self._get_k8s()
         namespace = k8s.resolve_namespace(namespace)

mlrun/runtimes/sparkjob/spark3job.py

@@ -100,7 +100,6 @@ class Spark3JobSpec(AbstractSparkJobSpec):
         driver_cores=None,
         executor_cores=None,
         security_context=None,
-        clone_target_dir=None,
     ):
 
         super().__init__(
@@ -130,7 +129,6 @@ class Spark3JobSpec(AbstractSparkJobSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
-            clone_target_dir=clone_target_dir,
         )
 
         self.driver_resources = driver_resources or {}

mlrun/serving/__init__.py

@@ -21,11 +21,10 @@ __all__ = [
     "TaskStep",
     "RouterStep",
     "QueueStep",
-    "ErrorStep",
 ]
 
 from .routers import ModelRouter, VotingEnsemble  # noqa
 from .server import GraphContext, GraphServer, create_graph_server  # noqa
-from .states import ErrorStep, QueueStep, RouterStep, TaskStep  # noqa
+from .states import QueueStep, RouterStep, TaskStep  # noqa
 from .v1_serving import MLModelServer, new_v1_model_server  # noqa
 from .v2_serving import V2ModelServer  # noqa