mlrun 1.3.3__py3-none-any.whl → 1.4.0__py3-none-any.whl

mlrun/package/utils/type_hint_utils.py

@@ -0,0 +1,298 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 builtins
+import importlib
+import itertools
+import re
+import sys
+import typing
+
+from mlrun.errors import MLRunInvalidArgumentError
+from mlrun.utils import logger
+
+
+class TypeHintUtils:
+    """
+    Static class for utilities functions to process type hints.
+    """
+
+    @staticmethod
+    def is_typing_type(type_hint: type) -> bool:
+        """
+        Check whether a given type is a type hint from one of the modules `typing` and `types`. The function will return
+        True for generic type aliases also, meaning Python 3.9's new hinting feature that includes hinting like
+        `list[int]` instead of `typing.List[int]`.
+
+        :param type_hint: The type to check.
+
+        :return: True if the type hint from `typing` / `types` and False otherwise.
+        """
+        # A type hint should be one of the based typing classes, meaning it will have "typing" as its module. Some
+        # typing classes are considered a type (like `TypeVar`) so we check their type as well. The only case "types"
+        # will be a module is for generic aliases like `list[int]`.
+        return (type_hint.__module__ == "typing") or (
+            type(type_hint).__module__ in ["typing", "types"]
+        )
+
+    @staticmethod
+    def parse_type_hint(type_hint: typing.Union[type, str]) -> type:
+        """
+        Parse a given type hint from string to its actual hinted type class object. The string must be one of the
+        following:
+
+        * Python builtin type - for example: `tuple`, `list`, `set`, `dict` and `bytearray`.
+        * Full module import path. An alias (if `import pandas as pd is used`, the type hint cannot be `pd.DataFrame`)
+          is not allowed.
+
+        The type class on its own (like `DataFrame`) cannot be used as the scope of this function is not the same as the
+        handler itself, hence modules and objects that were imported in the handler's scope are not available. This is
+        the same reason import aliases cannot be used as well.
+
+        If the provided type hint is not a string, it will simply be returned as is.
+
+        :param type_hint: The type hint to parse.
+
+        :return: The hinted type.
+
+        :raise MLRunInvalidArgumentError: In case the type hint is not following the 2 options mentioned above.
+        """
+        if not isinstance(type_hint, str):
+            return type_hint
+
+        # Validate the type hint is a valid module path:
+        if not bool(
+            re.fullmatch(
+                r"([a-zA-Z_][a-zA-Z0-9_]*\.)*[a-zA-Z_][a-zA-Z0-9_]*", type_hint
+            )
+        ):
+            raise MLRunInvalidArgumentError(
+                f"Invalid type hint. An input type hint must be a valid python class name or its module import path. "
+                f"For example: 'list', 'pandas.DataFrame', 'numpy.ndarray', 'sklearn.linear_model.LinearRegression'. "
+                f"Type hint given: '{type_hint}'."
+            )
+
+        # Look for a builtin type (rest of the builtin types like `int`, `str`, `float` should be treated as results,
+        # hence not given as an input to an MLRun function, but as a parameter):
+        builtin_types = {
+            builtin_name: builtin_type
+            for builtin_name, builtin_type in builtins.__dict__.items()
+            if isinstance(builtin_type, type)
+        }
+        if type_hint in builtin_types:
+            return builtin_types[type_hint]
+
+        # If it's not a builtin, its should have a full module path, meaning at least one '.' to separate the module and
+        # the class. If it doesn't, we will try to get the class from the main module:
+        if "." not in type_hint:
+            logger.warn(
+                f"The type hint string given '{type_hint}' is not a `builtins` python type. MLRun will try to look for "
+                f"it in the `__main__` module instead."
+            )
+            try:
+                return TypeHintUtils.parse_type_hint(type_hint=f"__main__.{type_hint}")
+            except MLRunInvalidArgumentError:
+                raise MLRunInvalidArgumentError(
+                    f"MLRun tried to get the type hint '{type_hint}' but it can't as it is not a valid builtin Python "
+                    f"type (one of `list`, `dict`, `str`, `int`, etc.) nor a locally declared type (from the "
+                    f"`__main__` module). Pay attention using only the type as string is not allowed as the handler's "
+                    f"scope is different than MLRun's. To properly give a type hint as string, please specify the full "
+                    f"module path without aliases. For example: do not use `DataFrame` or `pd.DataFrame`, use "
+                    f"`pandas.DataFrame`."
+                )
+
+        # Import the module to receive the hinted type:
+        try:
+            # Get the module path and the type class (If we'll wish to support inner classes, the `rsplit` won't work):
+            module_path, type_hint = type_hint.rsplit(".", 1)
+            # Replace alias if needed (alias assumed to be imported already, hence we look in globals):
+            # For example:
+            # If in handler scope there was `import A.B.C as abc` and user gave a type hint "abc.Something" then:
+            # `module_path[0]` will be equal to "abc". Then, because it is an alias, it will appear in the globals, so
+            # we'll replace the alias with the full module name in order to import the module.
+            module_path = module_path.split(".")
+            if module_path[0] in globals():
+                module_path[0] = globals()[module_path[0]].__name__
+            module_path = ".".join(module_path)
+            # Import the module:
+            module = importlib.import_module(module_path)
+            # Get the class type from the module:
+            type_hint = getattr(module, type_hint)
+        except ModuleNotFoundError as module_not_found_error:
+            # May be raised from `importlib.import_module` in case the module does not exist.
+            raise MLRunInvalidArgumentError(
+                f"MLRun tried to get the type hint '{type_hint}' but the module '{module_path}' cannot be imported. "
+                f"Keep in mind that using alias in the module path (meaning: import module as alias) is not allowed. "
+                f"If the module path is correct, please make sure the module package is installed in the python "
+                f"interpreter."
+            ) from module_not_found_error
+        except AttributeError as attribute_error:
+            # May be raised from `getattr(module, type_hint)` in case the class type cannot be imported directly from
+            # the imported module.
+            raise MLRunInvalidArgumentError(
+                f"MLRun tried to get the type hint '{type_hint}' from the module '{module.__name__}' but it seems it "
+                f"doesn't exist. Make sure the class can be imported from the module with the exact module path you "
+                f"passed. Notice inner classes (a class inside of a class) are not supported."
+            ) from attribute_error
+
+        return type_hint
+
+    @staticmethod
+    def is_matching(
+        object_type: type,
+        type_hint: typing.Union[type, typing.Set[type]],
+        include_subclasses: bool = True,
+        reduce_type_hint: bool = True,
+    ) -> bool:
+        """
+        Check if the given object type match the given hint.
+
+        :param object_type:        The object type to match with the type hint.
+        :param type_hint:          The hint to match with. Can be given as a set resulted from a reduced hint.
+        :param include_subclasses: Whether to mark a subclass as valid match. Default to True.
+        :param reduce_type_hint:   Whether to reduce the type hint to match with its reduced hints.
+
+        :return: True if the object type match the type hint and False otherwise.
+        """
+        # Wrap in a set if provided a single type hint:
+        type_hint = {type_hint} if not isinstance(type_hint, set) else type_hint
+
+        # Try to match the object type to one of the hints:
+        while len(type_hint) > 0:
+            for hint in type_hint:
+                # Subclass check can be made only on actual object types (not typing module types):
+                if (
+                    not TypeHintUtils.is_typing_type(type_hint=object_type)
+                    and not TypeHintUtils.is_typing_type(type_hint=hint)
+                    and include_subclasses
+                    and issubclass(object_type, hint)
+                ):
+                    return True
+                if object_type == hint:
+                    return True
+            # See if needed to reduce, if not end on first iteration:
+            if not reduce_type_hint:
+                break
+            type_hint = TypeHintUtils.reduce_type_hint(type_hint=type_hint)
+        return False
+
+    @staticmethod
+    def reduce_type_hint(
+        type_hint: typing.Union[type, typing.Set[type]],
+    ) -> typing.Set[type]:
+        """
+        Reduce a type hint (or a set of type hints) using the `_reduce_type_hint` function.
+
+        :param type_hint: The type hint to reduce.
+
+        :return: The reduced type hints set or an empty set if the type hint could not be reduced.
+        """
+        # Wrap in a set if provided a single type hint:
+        type_hints = {type_hint} if not isinstance(type_hint, set) else type_hint
+
+        # Iterate over the type hints and reduce each one:
+        return set(
+            itertools.chain(
+                *[
+                    TypeHintUtils._reduce_type_hint(type_hint=type_hint)
+                    for type_hint in type_hints
+                ]
+            )
+        )
+
+    @staticmethod
+    def _reduce_type_hint(type_hint: type) -> typing.List[type]:
+        """
+        Reduce a type hint. If the type hint is a `typing` module, it will be reduced to its original hinted types. For
+        example: `typing.Union[int, float, typing.List[int]]` will return `[int, float, List[int]]` and
+        `typing.List[int]` will return `[list]`. Regular type hints - Python object types cannot be reduced as they are
+        already a core type.
+
+        If a type hint cannot be reduced, an empty list will be returned.
+
+        :param type_hint: The type hint to reduce.
+
+        :return: The reduced type hint as list of hinted types or an empty list if the type hint could not be reduced.
+        """
+        # TODO: Remove when we'll no longer support Python 3.7:
+        if sys.version_info[1] < 8:
+            return []
+
+        # If it's not a typing type (meaning it's an actual object type) then we can't reduce it further:
+        if not TypeHintUtils.is_typing_type(type_hint=type_hint):
+            return []
+
+        # If it's a type var, take its constraints (e.g. A = TypeVar("A", int, str) meaning an object of type A should
+        # be an integer or a string). If it doesn't have constraints, return an empty list:
+        if isinstance(type_hint, typing.TypeVar):
+            if len(type_hint.__constraints__) == 0:
+                return []
+            return list(type_hint.__constraints__)
+
+        # If it's a forward reference, we will try to import the reference:
+        if isinstance(type_hint, typing.ForwardRef):
+            try:
+                # ForwardRef is initialized with the string type it represents and optionally a module path, so we
+                # construct a full module path and try to parse it:
+                arg = type_hint.__forward_arg__
+                if type_hint.__forward_module__:
+                    arg = f"{type_hint.__forward_module__}.{arg}"
+                return [TypeHintUtils.parse_type_hint(type_hint=arg)]
+            except MLRunInvalidArgumentError:  # May be raised from `TypeHintUtils.parse_type_hint`
+                logger.warn(
+                    f"Could not reduce the type hint '{type_hint}' as it is a forward reference to a class without "
+                    f"it's full module path. To enable importing forward references, please provide the full module "
+                    f"path to them. For example: use `ForwardRef('pandas.DataFrame')` instead of "
+                    f"`ForwardRef('DataFrame')`."
+                )
+                return []
+
+        # Get the origin of the typing type. An origin is the subscripted typing type (origin of Union[str, int] is
+        # Union). The origin can be one of Callable, Tuple, Union, Literal, Final, ClassVar, Annotated or the actual
+        # type alias (e.g. origin of List[int] is list):
+        origin = typing.get_origin(type_hint)
+
+        # If the typing type has no origin (e.g. None is returned), we cannot reduce it, so we return an empty list:
+        if origin is None:
+            return []
+
+        # If the origin is a type of one of `builtins`, `contextlib` or `collections` (for example: List's origin is
+        # list) then we can be sure there is nothing to reduce as it's a regular type:
+        if not TypeHintUtils.is_typing_type(type_hint=origin):
+            return [origin]
+
+        # Get the type's subscriptions - arguments, in order to reduce it to them (we know for sure there are arguments,
+        # otherwise origin would have been None):
+        args = typing.get_args(type_hint)
+
+        # Return the reduced type as its arguments according to the origin:
+        if origin is typing.Callable:
+            # A callable cannot be reduced to its arguments, so we'll return the origin - Callable:
+            return [typing.Callable]
+        if origin is typing.Literal:
+            # Literal arguments are not types, but values. So we'll take the types of the values as the reduced type:
+            return [type(arg) for arg in args]
+        if origin is typing.Union:
+            # A union is reduced to its arguments:
+            return list(args)
+        if origin is typing.Annotated:
+            # Annotated is used to describe (add metadata to) a type, so we take the first argument (the type the
+            # metadata is being added to):
+            return [args[0]]
+        if origin is typing.Final or origin is typing.ClassVar:
+            # Both Final and ClassVar takes only one argument - the type:
+            return [args[0]]
+
+        # For Generic types we return an empty list:
+        return []

mlrun/platforms/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

mlrun/platforms/iguazio.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -326,7 +326,6 @@ def v3io_to_vol(name, remote="~/", access_key="", user="", secret=None):
     if secret:
         secret = {"name": secret}
 
-    # vol = client.V1Volume(name=name, flex_volume=client.V1FlexVolumeSource('v3io/fuse', options=opts))
     vol = {
         "flexVolume": client.V1FlexVolumeSource(
             "v3io/fuse", options=opts, secret_ref=secret
@@ -403,6 +402,37 @@ 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,
@@ -650,6 +680,8 @@ 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/platforms/other.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

mlrun/projects/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

mlrun/projects/operations.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -70,8 +70,9 @@ def run_function(
     selector: str = None,
     project_object=None,
     auto_build: bool = None,
-    schedule: Union[str, mlrun.api.schemas.ScheduleCronTrigger] = None,
+    schedule: Union[str, mlrun.common.schemas.ScheduleCronTrigger] = None,
     artifact_path: str = None,
+    notifications: List[mlrun.model.Notification] = None,
     returns: Optional[List[Union[str, Dict[str, str]]]] = None,
 ) -> Union[mlrun.model.RunObject, kfp.dsl.ContainerOp]:
     """Run a local or remote task as part of a local/kubeflow pipeline
@@ -91,16 +92,16 @@ def run_function(
         LABELS = "is_error"
         MODEL_CLASS = "sklearn.ensemble.RandomForestClassifier"
         DATA_PATH = "s3://bigdata/data.parquet"
-        function = mlrun.import_function("hub://auto_trainer")
+        function = mlrun.import_function("hub://auto-trainer")
         run1 = run_function(function, params={"label_columns": LABELS, "model_class": MODEL_CLASS},
                                       inputs={"dataset": DATA_PATH})
 
     example (use with project)::
 
-        # create a project with two functions (local and from marketplace)
+        # create a project with two functions (local and from hub)
         project = mlrun.new_project(project_name, "./proj)
         project.set_function("mycode.py", "myfunc", image="mlrun/mlrun")
-        project.set_function("hub://auto_trainer", "train")
+        project.set_function("hub://auto-trainer", "train")
 
         # run functions (refer to them by name)
         run1 = run_function("myfunc", params={"x": 7})
@@ -111,7 +112,7 @@ def run_function(
 
         @dsl.pipeline(name="test pipeline", description="test")
         def my_pipe(url=""):
-            run1 = run_function("loaddata", params={"url": url})
+            run1 = run_function("loaddata", params={"url": url}, outputs=["data"])
             run2 = run_function("train", params={"label_columns": LABELS, "model_class": MODEL_CLASS},
                                          inputs={"dataset": run1.outputs["data"]})
 
@@ -137,12 +138,13 @@ def run_function(
     :param verbose:         add verbose prints/logs
     :param project_object:  override the project object to use, will default to the project set in the runtime context.
     :param auto_build:      when set to True and the function require build it will be built on the first
-                            function run, use only if you dont plan on changing the build config between runs
+                            function run, use only if you do not plan on changing the build config between runs
     :param schedule:        ScheduleCronTrigger class instance or a standard crontab expression string
                             (which will be converted to the class using its `from_crontab` constructor),
                             see this link for help:
                             https://apscheduler.readthedocs.io/en/3.x/modules/triggers/cron.html#module-apscheduler.triggers.cron
     :param artifact_path:   path to store artifacts, when running in a workflow this will be set automatically
+    :param notifications:   list of notifications to push when the run is completed
     :param returns:         List of log hints - configurations for how to log the returning values from the handler's
                             run (as artifacts or results). The list's length must be equal to the amount of returning
                             objects. A log hint may be given as:
@@ -198,6 +200,7 @@ def run_function(
             or (project.artifact_path if project else None),
             auto_build=auto_build,
             schedule=schedule,
+            notifications=notifications,
         )
         if run_result:
             run_result._notified = False
@@ -233,6 +236,7 @@ def build_function(
     commands: list = None,
     secret_name=None,
     requirements: Union[str, List[str]] = None,
+    requirements_file: str = None,
     mlrun_version_specifier=None,
     builder_env: dict = None,
     project_object=None,
@@ -247,7 +251,8 @@ def build_function(
     :param base_image:      base image name/path (commands and source code will be added to it)
     :param commands:        list of docker build (RUN) commands e.g. ['pip install pandas']
     :param secret_name:     k8s secret for accessing the docker registry
-    :param requirements:    list of python packages or pip requirements file path, defaults to None
+    :param requirements:    list of python packages, defaults to None
+    :param requirements_file:    pip requirements file path, defaults to None
     :param mlrun_version_specifier:  which mlrun package version to include (if not current)
     :param builder_env:     Kaniko builder pod env vars dict (for config/credentials)
                             e.g. builder_env={"GIT_TOKEN": token}, does not work yet in KFP
@@ -266,7 +271,7 @@ def build_function(
         if overwrite_build_params:
             function.spec.build.commands = None
         if requirements:
-            function.with_requirements(requirements)
+            function.with_requirements(requirements, requirements_file)
         if commands:
             function.with_commands(commands)
         return function.deploy_step(

mlrun/projects/pipelines.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -27,7 +27,7 @@ from kfp import dsl
 from kfp.compiler import compiler
 
 import mlrun
-import mlrun.api.schemas
+import mlrun.common.schemas
 import mlrun.utils.notifications
 from mlrun.errors import err_to_str
 from mlrun.utils import (
@@ -79,7 +79,7 @@ class WorkflowSpec(mlrun.model.ModelObj):
         # TODO: deprecated, remove in 1.5.0
         ttl=None,
         args_schema: dict = None,
-        schedule: typing.Union[str, mlrun.api.schemas.ScheduleCronTrigger] = None,
+        schedule: typing.Union[str, mlrun.common.schemas.ScheduleCronTrigger] = None,
         cleanup_ttl: int = None,
     ):
         if ttl:
@@ -116,7 +116,13 @@ class WorkflowSpec(mlrun.model.ModelObj):
                 self._tmp_path = workflow_path = workflow_fh.name
         else:
             workflow_path = self.path or ""
-            if context and not workflow_path.startswith("/"):
+            if (
+                context
+                and not workflow_path.startswith("/")
+                # since the user may provide a path the includes the context,
+                # we need to make sure we don't add it twice
+                and not workflow_path.startswith(context)
+            ):
                 workflow_path = os.path.join(context, workflow_path)
         return workflow_path
 
@@ -279,7 +285,7 @@ def _enrich_kfp_pod_security_context(kfp_pod_template, function):
     if (
         mlrun.runtimes.RuntimeKinds.is_local_runtime(function.kind)
         or mlrun.mlconf.function.spec.security_context.enrichment_mode
-        == mlrun.api.schemas.SecurityContextEnrichmentModes.disabled.value
+        == mlrun.common.schemas.SecurityContextEnrichmentModes.disabled.value
     ):
         return
 
@@ -405,7 +411,7 @@ def enrich_function_object(
             f.spec.build.source = project.spec.source
             f.spec.build.load_source_on_run = project.spec.load_source_on_run
             f.spec.workdir = project.spec.workdir or project.spec.subpath
-            f.verify_base_image()
+            f.prepare_image_for_deploy()
 
     if project.spec.default_requirements:
         f.with_requirements(project.spec.default_requirements)
@@ -705,7 +711,7 @@ class _LocalRunner(_PipelineRunner):
             trace = traceback.format_exc()
             logger.error(trace)
             project.notifiers.push(
-                f"Workflow {workflow_id} run failed!, error: {e}\n{trace}", "error"
+                f":x: Workflow {workflow_id} run failed!, error: {e}\n{trace}", "error"
             )
             state = mlrun.run.RunStatuses.failed
         mlrun.run.wait_for_runs_completion(pipeline_context.runs_map.values())
@@ -755,6 +761,7 @@ class _RemoteRunner(_PipelineRunner):
         artifact_path: str,
         workflow_handler: str,
         namespace: str,
+        subpath: str,
     ) -> typing.Tuple[mlrun.runtimes.RemoteRuntime, "mlrun.RunObject"]:
         """
         Helper function for creating the runspec of the load and run function.
@@ -767,6 +774,7 @@ class _RemoteRunner(_PipelineRunner):
         :param artifact_path:       path to store artifacts
         :param workflow_handler:    workflow function handler (for running workflow function directly)
         :param namespace:           kubernetes namespace if other than default
+        :param subpath:             project subpath (within the archive)
         :return:
         """
         # Creating the load project and workflow running function:
@@ -792,6 +800,7 @@ class _RemoteRunner(_PipelineRunner):
                     "engine": workflow_spec.engine,
                     "local": workflow_spec.run_local,
                     "schedule": workflow_spec.schedule,
+                    "subpath": subpath,
                 },
                 handler="mlrun.projects.load_and_run",
             ),
@@ -826,8 +835,11 @@ class _RemoteRunner(_PipelineRunner):
         )
         if "://" not in current_source:
             raise mlrun.errors.MLRunInvalidArgumentError(
-                f"remote workflows can only be performed by a project with remote source,"
-                f" the given source '{current_source}' is not remote"
+                f"Remote workflows can only be performed by a project with remote source (e.g git:// or http://),"
+                f" but the specified source '{current_source}' is not remote. "
+                f"Either put your code in Git, or archive it and then set a source to it."
+                f" For more details, read"
+                f" https://docs.mlrun.org/en/latest/concepts/scheduled-jobs.html#scheduling-a-workflow"
             )
 
         # Creating the load project and workflow running function:
@@ -840,6 +852,7 @@ class _RemoteRunner(_PipelineRunner):
             artifact_path=artifact_path,
             workflow_handler=workflow_handler,
             namespace=namespace,
+            subpath=project.spec.subpath,
         )
 
         # The returned engine for this runner is the engine of the workflow.
@@ -874,7 +887,8 @@ class _RemoteRunner(_PipelineRunner):
             trace = traceback.format_exc()
             logger.error(trace)
             project.notifiers.push(
-                f"Workflow {workflow_name} run failed!, error: {e}\n{trace}", "error"
+                f":x: Workflow {workflow_name} run failed!, error: {e}\n{trace}",
+                "error",
             )
             state = mlrun.run.RunStatuses.failed
             return _PipelineRunStatus(
@@ -928,7 +942,11 @@ def create_pipeline(project, pipeline, functions, secrets=None, handler=None):
     if not handler and hasattr(mod, "pipeline"):
         handler = "pipeline"
     if not handler or not hasattr(mod, handler):
-        raise ValueError(f"pipeline function ({handler or 'pipeline'}) not found")
+        raise ValueError(
+            f"'workflow_handler' is not defined. "
+            f"Either provide it as set_workflow argument, or include a function named"
+            f" '{handler or 'pipeline'}' in your workflow .py file."
+        )
 
     return getattr(mod, handler)
 
@@ -967,7 +985,7 @@ def load_and_run(
     ttl: int = None,
     engine: str = None,
     local: bool = None,
-    schedule: typing.Union[str, mlrun.api.schemas.ScheduleCronTrigger] = None,
+    schedule: typing.Union[str, mlrun.common.schemas.ScheduleCronTrigger] = None,
     cleanup_ttl: int = None,
 ):
     """
@@ -1033,7 +1051,7 @@ def load_and_run(
             try:
                 notification_pusher.push(
                     message=message,
-                    severity=mlrun.utils.notifications.NotificationSeverity.ERROR,
+                    severity=mlrun.common.schemas.NotificationSeverity.ERROR,
                 )
 
             except Exception as exc: