mlrun 1.6.2rc3__py3-none-any.whl → 1.6.2rc6__py3-none-any.whl

mlrun/k8s_utils.py

@@ -134,13 +134,13 @@ def sanitize_label_value(value: str) -> str:
     return re.sub(r"([^a-zA-Z0-9_.-]|^[^a-zA-Z0-9]|[^a-zA-Z0-9]$)", "-", value[:63])
 
 
-def verify_label_key(key: str):
-    """
-    Verify that the label key is valid for Kubernetes.
-    Refer to https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#syntax-and-character-set
-    """
+def verify_label_key(key):
     if not key:
         raise mlrun.errors.MLRunInvalidArgumentError("label key cannot be empty")
+    if key.startswith("k8s.io") or key.startswith("kubernetes.io"):
+        raise mlrun.errors.MLRunInvalidArgumentError(
+            "Labels cannot start with 'k8s.io' or 'kubernetes.io'"
+        )
 
     mlrun.utils.helpers.verify_field_regex(
         f"project.metadata.labels.'{key}'",
@@ -148,11 +148,6 @@ def verify_label_key(key: str):
         mlrun.utils.regex.k8s_character_limit,
     )
 
-    if key.startswith("k8s.io/") or key.startswith("kubernetes.io/"):
-        raise mlrun.errors.MLRunInvalidArgumentError(
-            "Labels cannot start with 'k8s.io/' or 'kubernetes.io/'"
-        )
-
     parts = key.split("/")
     if len(parts) == 1:
         name = parts[0]

mlrun/kfpops.py

@@ -41,8 +41,8 @@ from .utils import (
 
 # default KFP artifacts and output (ui metadata, metrics etc.)
 # directories to /tmp to allow running with security context
-KFPMETA_DIR = "/tmp"
-KFP_ARTIFACTS_DIR = "/tmp"
+KFPMETA_DIR = os.environ.get("KFPMETA_OUT_DIR", "/tmp")
+KFP_ARTIFACTS_DIR = os.environ.get("KFP_ARTIFACTS_DIR", "/tmp")
 
 project_annotation = "mlrun/project"
 run_annotation = "mlrun/pipeline-step-type"
@@ -71,7 +71,7 @@ def write_kfpmeta(struct):
             {"name": k, "numberValue": v} for k, v in results.items() if is_num(v)
         ],
     }
-    with open(os.path.join(KFPMETA_DIR, "mlpipeline-metrics.json"), "w") as f:
+    with open(KFPMETA_DIR + "/mlpipeline-metrics.json", "w") as f:
         json.dump(metrics, f)
 
     struct = deepcopy(struct)
@@ -91,14 +91,7 @@ def write_kfpmeta(struct):
         elif key in results:
             val = results[key]
         try:
-            # NOTE: if key has "../x", it would fail on path traversal
-            path = os.path.join(KFP_ARTIFACTS_DIR, key)
-            if not mlrun.utils.helpers.is_safe_path(KFP_ARTIFACTS_DIR, path):
-                logger.warning(
-                    "Path traversal is not allowed ignoring", path=path, key=key
-                )
-                continue
-            path = os.path.abspath(path)
+            path = "/".join([KFP_ARTIFACTS_DIR, key])
             logger.info("Writing artifact output", path=path, val=val)
             with open(path, "w") as fp:
                 fp.write(str(val))
@@ -116,7 +109,7 @@ def write_kfpmeta(struct):
         "outputs": output_artifacts
         + [{"type": "markdown", "storage": "inline", "source": text}]
     }
-    with open(os.path.join(KFPMETA_DIR, "mlpipeline-ui-metadata.json"), "w") as f:
+    with open(KFPMETA_DIR + "/mlpipeline-ui-metadata.json", "w") as f:
         json.dump(metadata, f)
 
 
@@ -408,9 +401,9 @@ def mlrun_op(
         cmd += ["--label", f"{label}={val}"]
     for output in outputs:
         cmd += ["-o", str(output)]
-        file_outputs[output.replace(".", "_")] = (
-            f"/tmp/{output}"  # not using path.join to avoid windows "\"
-        )
+        file_outputs[
+            output.replace(".", "_")
+        ] = f"/tmp/{output}"  # not using path.join to avoid windows "\"
     if project:
         cmd += ["--project", project]
     if handler:
@@ -457,10 +450,8 @@ def mlrun_op(
         command=cmd + [command],
         file_outputs=file_outputs,
         output_artifact_paths={
-            "mlpipeline-ui-metadata": os.path.join(
-                KFPMETA_DIR, "mlpipeline-ui-metadata.json"
-            ),
-            "mlpipeline-metrics": os.path.join(KFPMETA_DIR, "mlpipeline-metrics.json"),
+            "mlpipeline-ui-metadata": KFPMETA_DIR + "/mlpipeline-ui-metadata.json",
+            "mlpipeline-metrics": KFPMETA_DIR + "/mlpipeline-metrics.json",
         },
     )
     cop = add_default_function_resources(cop)

mlrun/model.py

@@ -359,7 +359,6 @@ class ImageBuilder(ModelObj):
         requirements: list = None,
         extra_args=None,
         builder_env=None,
-        source_code_target_dir=None,
     ):
         self.functionSourceCode = functionSourceCode  #: functionSourceCode
         self.codeEntryType = ""  #: codeEntryType
@@ -380,7 +379,6 @@ class ImageBuilder(ModelObj):
         self.auto_build = auto_build  #: auto_build
         self.build_pod = None
         self.requirements = requirements or []  #: pip requirements
-        self.source_code_target_dir = source_code_target_dir or None
 
     @property
     def source(self):
@@ -417,7 +415,6 @@ class ImageBuilder(ModelObj):
         overwrite=False,
         builder_env=None,
         extra_args=None,
-        source_code_target_dir=None,
     ):
         if image:
             self.image = image
@@ -443,8 +440,6 @@ class ImageBuilder(ModelObj):
             self.builder_env = builder_env
         if extra_args:
             self.extra_args = extra_args
-        if source_code_target_dir:
-            self.source_code_target_dir = source_code_target_dir
 
     def with_commands(
         self,

mlrun/model_monitoring/api.py

@@ -436,9 +436,9 @@ def _generate_model_endpoint(
         ] = possible_drift_threshold
 
     model_endpoint.spec.monitoring_mode = monitoring_mode
-    model_endpoint.status.first_request = model_endpoint.status.last_request = (
-        datetime_now().isoformat()
-    )
+    model_endpoint.status.first_request = (
+        model_endpoint.status.last_request
+    ) = datetime_now().isoformat()
     if sample_set_statistics:
         model_endpoint.status.feature_stats = sample_set_statistics
 
@@ -476,11 +476,11 @@ def trigger_drift_batch_job(
         db_session = mlrun.get_run_db()
 
     # Register the monitoring batch job (do nothing if already exist) and get the job function as a dictionary
-    batch_function_dict: typing.Dict[str, typing.Any] = (
-        db_session.deploy_monitoring_batch_job(
-            project=project,
-            default_batch_image=default_batch_image,
-        )
+    batch_function_dict: typing.Dict[
+        str, typing.Any
+    ] = db_session.deploy_monitoring_batch_job(
+        project=project,
+        default_batch_image=default_batch_image,
     )
 
     # Prepare current run params

mlrun/model_monitoring/batch.py

@@ -992,7 +992,7 @@ class BatchProcessor:
         """
         stream_http_path = (
             mlrun.mlconf.model_endpoint_monitoring.default_http_sink.format(
-                project=self.project, namespace=mlrun.mlconf.namespace
+                project=self.project
             )
         )
 

mlrun/model_monitoring/stores/kv_model_endpoint_store.py

@@ -540,24 +540,24 @@ class KVModelEndpointStore(ModelEndpointStore):
             and endpoint[mlrun.common.schemas.model_monitoring.EventFieldType.METRICS]
             == "null"
         ):
-            endpoint[mlrun.common.schemas.model_monitoring.EventFieldType.METRICS] = (
-                json.dumps(
-                    {
-                        mlrun.common.schemas.model_monitoring.EventKeyMetrics.GENERIC: {
-                            mlrun.common.schemas.model_monitoring.EventLiveStats.LATENCY_AVG_1H: 0,
-                            mlrun.common.schemas.model_monitoring.EventLiveStats.PREDICTIONS_PER_SECOND: 0,
-                        }
+            endpoint[
+                mlrun.common.schemas.model_monitoring.EventFieldType.METRICS
+            ] = json.dumps(
+                {
+                    mlrun.common.schemas.model_monitoring.EventKeyMetrics.GENERIC: {
+                        mlrun.common.schemas.model_monitoring.EventLiveStats.LATENCY_AVG_1H: 0,
+                        mlrun.common.schemas.model_monitoring.EventLiveStats.PREDICTIONS_PER_SECOND: 0,
                     }
-                )
+                }
             )
         # Validate key `uid` instead of `endpoint_id`
         # For backwards compatibility reasons, we replace the `endpoint_id` with `uid` which is the updated key name
         if mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID in endpoint:
-            endpoint[mlrun.common.schemas.model_monitoring.EventFieldType.UID] = (
-                endpoint[
-                    mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID
-                ]
-            )
+            endpoint[
+                mlrun.common.schemas.model_monitoring.EventFieldType.UID
+            ] = endpoint[
+                mlrun.common.schemas.model_monitoring.EventFieldType.ENDPOINT_ID
+            ]
 
     @staticmethod
     def _encode_field(field: typing.Union[str, bytes]) -> bytes:

mlrun/model_monitoring/stores/sql_model_endpoint_store.py

@@ -31,6 +31,7 @@ from .models import get_model_endpoints_table
 
 
 class SQLModelEndpointStore(ModelEndpointStore):
+
     """
     Handles the DB operations when the DB target is from type SQL. For the SQL operations, we use SQLAlchemy, a Python
     SQL toolkit that handles the communication with the database.  When using SQL for storing the model endpoints

mlrun/package/packagers/pandas_packagers.py

@@ -838,9 +838,9 @@ class PandasDataFramePackager(DefaultPackager):
         """
         if isinstance(obj, dict):
             for key, value in obj.items():
-                obj[PandasDataFramePackager._prepare_result(obj=key)] = (
-                    PandasDataFramePackager._prepare_result(obj=value)
-                )
+                obj[
+                    PandasDataFramePackager._prepare_result(obj=key)
+                ] = PandasDataFramePackager._prepare_result(obj=value)
         elif isinstance(obj, list):
             for i, value in enumerate(obj):
                 obj[i] = PandasDataFramePackager._prepare_result(obj=value)

mlrun/package/utils/_archiver.py

@@ -179,9 +179,7 @@ class _TarArchiver(_Archiver):
 
         # Extract:
         with tarfile.open(archive_path, f"r:{cls._MODE_STRING}") as tar_file:
-            # use 'data' to ensure no security risks are imposed by the archive files
-            # see: https://docs.python.org/3/library/tarfile.html#tarfile.TarFile.extractall
-            tar_file.extractall(directory_path, filter="data")
+            tar_file.extractall(directory_path)
 
         return str(directory_path)
 

mlrun/platforms/iguazio.py

@@ -16,15 +16,19 @@ import json
 import os
 import urllib
 from collections import namedtuple
+from datetime import datetime
+from http import HTTPStatus
 from urllib.parse import urlparse
 
 import kfp.dsl
 import requests
 import semver
+import urllib3
 import v3io
 
 import mlrun.errors
 from mlrun.config import config as mlconf
+from mlrun.errors import err_to_str
 from mlrun.utils import dict_to_json
 
 _cached_control_session = None
@@ -484,6 +488,25 @@ class V3ioStreamClient:
         return response.output.records
 
 
+def create_control_session(url, username, password):
+    # for systems without production cert - silence no cert verification WARN
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+    if not username or not password:
+        raise ValueError("cannot create session key, missing username or password")
+
+    session = requests.Session()
+    session.auth = (username, password)
+    try:
+        auth = session.post(f"{url}/api/sessions", verify=False)
+    except OSError as exc:
+        raise OSError(f"error: cannot connect to {url}: {err_to_str(exc)}")
+
+    if not auth.ok:
+        raise OSError(f"failed to create session: {url}, {auth.text}")
+
+    return auth.json()["data"]["id"]
+
+
 def is_iguazio_endpoint(endpoint_url: str) -> bool:
     # TODO: find a better heuristic
     return ".default-tenant." in endpoint_url
@@ -510,6 +533,21 @@ def is_iguazio_session_cookie(session_cookie: str) -> bool:
         return False
 
 
+def is_iguazio_system_2_10_or_above(dashboard_url):
+    # for systems without production cert - silence no cert verification WARN
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+    response = requests.get(f"{dashboard_url}/api/external_versions", verify=False)
+
+    if not response.ok:
+        if response.status_code == HTTPStatus.NOT_FOUND.value:
+            # in iguazio systems prior to 2.10 this endpoint didn't exist, so the api returns 404 cause endpoint not
+            # found
+            return False
+        response.raise_for_status()
+
+    return True
+
+
 # we assign the control session or access key to the password since this is iguazio auth scheme
 # (requests should be sent with username:control_session/access_key as auth header)
 def add_or_refresh_credentials(
@@ -539,12 +577,33 @@ def add_or_refresh_credentials(
     # (ideally if we could identify we're in enterprise we would have verify here that token and username have value)
     if not is_iguazio_endpoint(api_url):
         return "", "", token
-
-    if not username or not token:
-        raise ValueError(
-            "username and access key required to authenticate against iguazio system"
-        )
-    return username, token, ""
+    iguazio_dashboard_url = "https://dashboard" + api_url[api_url.find(".") :]
+
+    # in 2.8 mlrun api is protected with control session, from 2.10 it's protected with access key
+    is_access_key_auth = is_iguazio_system_2_10_or_above(iguazio_dashboard_url)
+    if is_access_key_auth:
+        if not username or not token:
+            raise ValueError(
+                "username and access key required to authenticate against iguazio system"
+            )
+        return username, token, ""
+
+    if not username or not password:
+        raise ValueError("username and password needed to create session")
+
+    global _cached_control_session
+    now = datetime.now()
+    if _cached_control_session:
+        if (
+            _cached_control_session[2] == username
+            and _cached_control_session[3] == password
+            and (now - _cached_control_session[1]).seconds < 20 * 60 * 60
+        ):
+            return _cached_control_session[2], _cached_control_session[0], ""
+
+    control_session = create_control_session(iguazio_dashboard_url, username, password)
+    _cached_control_session = (control_session, now, username, password)
+    return username, control_session, ""
 
 
 def parse_path(url, suffix="/"):

mlrun/projects/pipelines.py

@@ -69,16 +69,16 @@ class WorkflowSpec(mlrun.model.ModelObj):
 
     def __init__(
         self,
-        engine: typing.Optional[str] = None,
-        code: typing.Optional[str] = None,
-        path: typing.Optional[str] = None,
-        args: typing.Optional[dict] = None,
-        name: typing.Optional[str] = None,
-        handler: typing.Optional[str] = None,
-        args_schema: typing.Optional[dict] = None,
+        engine=None,
+        code=None,
+        path=None,
+        args=None,
+        name=None,
+        handler=None,
+        args_schema: dict = None,
         schedule: typing.Union[str, mlrun.common.schemas.ScheduleCronTrigger] = None,
-        cleanup_ttl: typing.Optional[int] = None,
-        image: typing.Optional[str] = None,
+        cleanup_ttl: int = None,
+        image: str = None,
     ):
         self.engine = engine
         self.code = code
@@ -401,9 +401,6 @@ def enrich_function_object(
         else:
             f.spec.build.source = project.spec.source
             f.spec.build.load_source_on_run = project.spec.load_source_on_run
-            f.spec.build.source_code_target_dir = (
-                project.spec.build.source_code_target_dir
-            )
             f.spec.workdir = project.spec.workdir or project.spec.subpath
             f.prepare_image_for_deploy()
 
@@ -865,11 +862,6 @@ class _RemoteRunner(_PipelineRunner):
                 )
                 return
 
-            logger.debug(
-                "Workflow submitted, waiting for pipeline run to start",
-                workflow_name=workflow_response.name,
-            )
-
             # Getting workflow id from run:
             response = retry_until_successful(
                 1,
@@ -996,7 +988,6 @@ def load_and_run(
     cleanup_ttl: int = None,
     load_only: bool = False,
     wait_for_completion: bool = False,
-    project_context: str = None,
 ):
     """
     Auxiliary function that the RemoteRunner run once or run every schedule.
@@ -1027,11 +1018,10 @@ def load_and_run(
                                 workflow and all its resources are deleted)
     :param load_only:           for just loading the project, inner use.
     :param wait_for_completion: wait for workflow completion before returning
-    :param project_context:     project context path (used for loading the project)
     """
     try:
         project = mlrun.load_project(
-            context=project_context or f"./{project_name}",
+            context=f"./{project_name}",
             url=url,
             name=project_name,
             init_git=init_git,
@@ -1063,7 +1053,7 @@ def load_and_run(
 
         raise error
 
-    context.logger.info(f"Loaded project {project.name} successfully")
+    context.logger.info(f"Loaded project {project.name} from remote successfully")
 
     if load_only:
         return

mlrun/projects/project.py

@@ -24,7 +24,7 @@ import typing
 import uuid
 import warnings
 import zipfile
-from os import environ, makedirs, path
+from os import environ, makedirs, path, remove
 from typing import Callable, Dict, List, Optional, Union
 
 import dotenv
@@ -605,14 +605,9 @@ def _load_project_dir(context, name="", subpath=""):
         # If there is a setup script do not force having project.yaml file
         project = MlrunProject()
     else:
-        message = "Project or function YAML not found in path"
-        logger.error(
-            message,
-            context=context,
-            name=name,
-            subpath=subpath,
+        raise mlrun.errors.MLRunNotFoundError(
+            "project or function YAML not found in path"
         )
-        raise mlrun.errors.MLRunNotFoundError(message)
 
     project.spec.context = context
     project.metadata.name = name or project.metadata.name
@@ -1240,20 +1235,20 @@ class MlrunProject(ModelObj):
         self,
         name,
         workflow_path: str,
-        embed: bool = False,
-        engine: Optional[str] = None,
-        args_schema: list[EntrypointParam] = None,
-        handler: Optional[str] = None,
+        embed=False,
+        engine=None,
+        args_schema: typing.List[EntrypointParam] = None,
+        handler=None,
         schedule: typing.Union[str, mlrun.common.schemas.ScheduleCronTrigger] = None,
-        ttl: Optional[int] = None,
-        image: Optional[str] = None,
+        ttl=None,
+        image: str = None,
         **args,
     ):
         """Add or update a workflow, specify a name and the code path
 
         :param name:          Name of the workflow
         :param workflow_path: URL (remote) / Path (absolute or relative to the project code path i.e.
-            <project.spec.get_code_path()>/<workflow_path>) for the workflow file.
+                <project.spec.get_code_path()>/<workflow_path>) for the workflow file.
         :param embed:         Add the workflow code into the project.yaml
         :param engine:        Workflow processing engine ("kfp", "local", "remote" or "remote:local")
         :param args_schema:   List of arg schema definitions (:py:class`~mlrun.model.EntrypointParam`)
@@ -2600,45 +2595,40 @@ class MlrunProject(ModelObj):
         cleanup_ttl: int = None,
         notifications: typing.List[mlrun.model.Notification] = None,
     ) -> _PipelineRunStatus:
-        """Run a workflow using kubeflow pipelines
+        """run a workflow using kubeflow pipelines
 
-        :param name:      Name of the workflow
+        :param name:      name of the workflow
         :param workflow_path:
-                          URL to a workflow file, if not a project workflow
+                          url to a workflow file, if not a project workflow
         :param arguments:
-                          Kubeflow pipelines arguments (parameters)
+                          kubeflow pipelines arguments (parameters)
         :param artifact_path:
-                          Target path/url for workflow artifacts, the string
+                          target path/url for workflow artifacts, the string
                           '{{workflow.uid}}' will be replaced by workflow id
         :param workflow_handler:
-                          Workflow function handler (for running workflow function directly)
-        :param namespace: Kubernetes namespace if other than default
-        :param sync:      Force functions sync before run
-        :param watch:     Wait for pipeline completion
-        :param dirty:     Allow running the workflow when the git repo is dirty
-        :param engine:    Workflow engine running the workflow.
-                          Supported values are 'kfp' (default), 'local' or 'remote'.
-                          For setting engine for remote running use 'remote:local' or 'remote:kfp'.
-        :param local:     Run local pipeline with local functions (set local=True in function.run())
+                          workflow function handler (for running workflow function directly)
+        :param namespace: kubernetes namespace if other than default
+        :param sync:      force functions sync before run
+        :param watch:     wait for pipeline completion
+        :param dirty:     allow running the workflow when the git repo is dirty
+        :param engine:    workflow engine running the workflow.
+                          supported values are 'kfp' (default), 'local' or 'remote'.
+                          for setting engine for remote running use 'remote:local' or 'remote:kfp'.
+        :param local:     run local pipeline with local functions (set local=True in function.run())
         :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
                           for using the pre-defined workflow's schedule, set `schedule=True`
-        :param timeout:   Timeout in seconds to wait for pipeline completion (watch will be activated)
-        :param source:    Source to use instead of the actual `project.spec.source` (used when engine is remote).
-                          Can be a one of:
-                            1. Remote URL which is loaded dynamically to the workflow runner.
-                            2. A path to the project's context on the workflow runner's image.
-                          Path can be absolute or relative to `project.spec.build.source_code_target_dir` if defined
-                          (enriched when building a project image with source, see `MlrunProject.build_image`).
-                          For other engines the source is used to validate that the code is up-to-date.
+        :param timeout:   timeout in seconds to wait for pipeline completion (watch will be activated)
+        :param source:    remote source to use instead of the actual `project.spec.source` (used when engine is remote).
+                          for other engines the source is to validate that the code is up-to-date
         :param cleanup_ttl:
-                          Pipeline cleanup ttl in secs (time to wait after workflow completion, at which point the
-                          Workflow and all its resources are deleted)
+                          pipeline cleanup ttl in secs (time to wait after workflow completion, at which point the
+                          workflow and all its resources are deleted)
         :param notifications:
-                          List of notifications to send for workflow completion
-        :returns: Run id
+                          list of notifications to send for workflow completion
+        :returns: run id
         """
 
         arguments = arguments or {}
@@ -2785,7 +2775,7 @@ class MlrunProject(ModelObj):
     def export(self, filepath=None, include_files: str = None):
         """save the project object into a yaml file or zip archive (default to project.yaml)
 
-        By default, the project object is exported to a yaml file, when the filepath suffix is '.zip'
+        By default the project object is exported to a yaml file, when the filepath suffix is '.zip'
         the project context dir (code files) are also copied into the zip, the archive path can include
         DataItem urls (for remote object storage, e.g. s3://<bucket>/<path>).
 
@@ -2810,19 +2800,19 @@ class MlrunProject(ModelObj):
 
         if archive_code:
             files_filter = include_files or "**"
-            with tempfile.NamedTemporaryFile(suffix=".zip") as f:
-                remote_file = "://" in filepath
-                fpath = f.name if remote_file else filepath
-                with zipfile.ZipFile(fpath, "w") as zipf:
-                    for file_path in glob.iglob(
-                        f"{project_dir}/{files_filter}", recursive=True
-                    ):
-                        write_path = pathlib.Path(file_path)
-                        zipf.write(
-                            write_path, arcname=write_path.relative_to(project_dir)
-                        )
-                if remote_file:
-                    mlrun.get_dataitem(filepath).upload(zipf.filename)
+            tmp_path = None
+            if "://" in filepath:
+                tmp_path = tempfile.mktemp(".zip")
+            zipf = zipfile.ZipFile(tmp_path or filepath, "w")
+            for file_path in glob.iglob(
+                f"{project_dir}/{files_filter}", recursive=True
+            ):
+                write_path = pathlib.Path(file_path)
+                zipf.write(write_path, arcname=write_path.relative_to(project_dir))
+            zipf.close()
+            if tmp_path:
+                mlrun.get_dataitem(filepath).upload(tmp_path)
+                remove(tmp_path)
 
     def set_model_monitoring_credentials(
         self,
@@ -3037,7 +3027,6 @@ class MlrunProject(ModelObj):
         requirements_file: str = None,
         builder_env: dict = None,
         extra_args: str = None,
-        source_code_target_dir: str = None,
     ):
         """specify builder configuration for the project
 
@@ -3058,8 +3047,6 @@ class MlrunProject(ModelObj):
             e.g. builder_env={"GIT_TOKEN": token}, does not work yet in KFP
         :param extra_args:  A string containing additional builder arguments in the format of command-line options,
             e.g. extra_args="--skip-tls-verify --build-arg A=val"
-        :param source_code_target_dir: Path on the image where source code would be extracted
-            (by default `/home/mlrun_code`)
         """
         if not overwrite_build_params:
             # TODO: change overwrite_build_params default to True in 1.8.0
@@ -3083,7 +3070,6 @@ class MlrunProject(ModelObj):
             overwrite=overwrite_build_params,
             builder_env=builder_env,
             extra_args=extra_args,
-            source_code_target_dir=source_code_target_dir,
         )
 
         if set_as_default and image != self.default_image:
@@ -3130,7 +3116,7 @@ class MlrunProject(ModelObj):
             * False: The new params are merged with the existing
             * True: The existing params are replaced by the new ones
         :param extra_args:  A string containing additional builder arguments in the format of command-line options,
-            e.g. extra_args="--skip-tls-verify --build-arg A=val"
+            e.g. extra_args="--skip-tls-verify --build-arg A=val"r
         :param target_dir: Path on the image where source code would be extracted (by default `/home/mlrun_code`)
         """
         if not base_image:
@@ -3198,11 +3184,6 @@ class MlrunProject(ModelObj):
                 force_build=True,
             )
 
-            # Get the enriched target dir from the function
-            self.spec.build.source_code_target_dir = (
-                function.spec.build.source_code_target_dir
-            )
-
         try:
             mlrun.db.get_run_db(secrets=self._secrets).delete_function(
                 name=function.metadata.name