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

mlrun/db/httpdb.py

@@ -152,7 +152,7 @@ class HTTPRunDB(RunDBInterface):
     @staticmethod
     def get_api_path_prefix(version: str = None) -> str:
         """
-        :param version: API version to use, None (the default) will mean to use the default value from mlrun.config,
+        :param version: API version to use, None (the default) will mean to use the default value from mlconf,
          for un-versioned api set an empty string.
         """
         if version is not None:
@@ -250,11 +250,7 @@ class HTTPRunDB(RunDBInterface):
 
         try:
             response = self.session.request(
-                method,
-                url,
-                timeout=timeout,
-                verify=config.httpdb.http.verify,
-                **kw,
+                method, url, timeout=timeout, verify=False, **kw
             )
         except requests.RequestException as exc:
             error = f"{err_to_str(exc)}: {error}" if error else err_to_str(exc)
@@ -306,11 +302,11 @@ class HTTPRunDB(RunDBInterface):
 
     def connect(self, secrets=None):
         """Connect to the MLRun API server. Must be called prior to executing any other method.
-        The code utilizes the URL for the API server from the configuration - ``config.dbpath``.
+        The code utilizes the URL for the API server from the configuration - ``mlconf.dbpath``.
 
         For example::
 
-            config.dbpath = config.dbpath or 'http://mlrun-api:8080'
+            mlconf.dbpath = mlconf.dbpath or 'http://mlrun-api:8080'
             db = get_run_db().connect()
         """
         # hack to allow unit tests to instantiate HTTPRunDB without a real server behind
@@ -504,7 +500,7 @@ class HTTPRunDB(RunDBInterface):
         if offset < 0:
             raise MLRunInvalidArgumentError("Offset cannot be negative")
         if size is None:
-            size = int(config.httpdb.logs.pull_logs_default_size_limit)
+            size = int(mlrun.mlconf.httpdb.logs.pull_logs_default_size_limit)
         elif size == -1:
             logger.warning(
                 "Retrieving all logs. This may be inefficient and can result in a large log."
@@ -550,23 +546,25 @@ class HTTPRunDB(RunDBInterface):
 
         state, text = self.get_log(uid, project, offset=offset)
         if text:
-            print(text.decode(errors=config.httpdb.logs.decode.errors))
+            print(text.decode(errors=mlrun.mlconf.httpdb.logs.decode.errors))
         nil_resp = 0
         while True:
             offset += len(text)
             # if we get 3 nil responses in a row, increase the sleep time to 10 seconds
             # TODO: refactor this to use a conditional backoff mechanism
             if nil_resp < 3:
-                time.sleep(int(config.httpdb.logs.pull_logs_default_interval))
+                time.sleep(int(mlrun.mlconf.httpdb.logs.pull_logs_default_interval))
             else:
                 time.sleep(
-                    int(config.httpdb.logs.pull_logs_backoff_no_logs_default_interval)
+                    int(
+                        mlrun.mlconf.httpdb.logs.pull_logs_backoff_no_logs_default_interval
+                    )
                 )
             state, text = self.get_log(uid, project, offset=offset)
             if text:
                 nil_resp = 0
                 print(
-                    text.decode(errors=config.httpdb.logs.decode.errors),
+                    text.decode(errors=mlrun.mlconf.httpdb.logs.decode.errors),
                     end="",
                 )
             else:
@@ -1137,17 +1135,17 @@ class HTTPRunDB(RunDBInterface):
             structured_dict = {}
             for project, job_runtime_resources_map in response.json().items():
                 for job_id, runtime_resources in job_runtime_resources_map.items():
-                    structured_dict.setdefault(project, {})[job_id] = (
-                        mlrun.common.schemas.RuntimeResources(**runtime_resources)
-                    )
+                    structured_dict.setdefault(project, {})[
+                        job_id
+                    ] = mlrun.common.schemas.RuntimeResources(**runtime_resources)
             return structured_dict
         elif group_by == mlrun.common.schemas.ListRuntimeResourcesGroupByField.project:
             structured_dict = {}
             for project, kind_runtime_resources_map in response.json().items():
                 for kind, runtime_resources in kind_runtime_resources_map.items():
-                    structured_dict.setdefault(project, {})[kind] = (
-                        mlrun.common.schemas.RuntimeResources(**runtime_resources)
-                    )
+                    structured_dict.setdefault(project, {})[
+                        kind
+                    ] = mlrun.common.schemas.RuntimeResources(**runtime_resources)
             return structured_dict
         else:
             raise NotImplementedError(
@@ -1175,8 +1173,7 @@ class HTTPRunDB(RunDBInterface):
         :param force: Force deletion - delete the runtime resource even if it's not in terminal state or if the grace
             period didn't pass.
         :param grace_period: Grace period given to the runtime resource before they are actually removed, counted from
-            the moment they moved to terminal state
-            (defaults to mlrun.config.config.runtime_resources_deletion_grace_period).
+            the moment they moved to terminal state (defaults to mlrun.mlconf.runtime_resources_deletion_grace_period).
 
         :returns: :py:class:`~mlrun.common.schemas.GroupedByProjectRuntimeResourcesOutput` listing the runtime resources
             that were removed.
@@ -1206,9 +1203,9 @@ class HTTPRunDB(RunDBInterface):
         structured_dict = {}
         for project, kind_runtime_resources_map in response.json().items():
             for kind, runtime_resources in kind_runtime_resources_map.items():
-                structured_dict.setdefault(project, {})[kind] = (
-                    mlrun.common.schemas.RuntimeResources(**runtime_resources)
-                )
+                structured_dict.setdefault(project, {})[
+                    kind
+                ] = mlrun.common.schemas.RuntimeResources(**runtime_resources)
         return structured_dict
 
     def create_schedule(
@@ -1343,7 +1340,7 @@ class HTTPRunDB(RunDBInterface):
             logger.warning(
                 "Building a function image to ECR and loading an S3 source to the image may require conflicting access "
                 "keys. Only the permissions granted to the platform's configured secret will take affect "
-                "(see mlrun.config.config.httpdb.builder.docker_registry_secret). "
+                "(see mlrun.mlconf.httpdb.builder.docker_registry_secret). "
                 "In case the permissions are limited to ECR scope, you may use pull_at_runtime=True instead",
                 source=func.spec.build.source,
                 load_source_on_run=func.spec.build.load_source_on_run,
@@ -1498,7 +1495,7 @@ class HTTPRunDB(RunDBInterface):
         Retrieve updated information on project background tasks being executed.
         If no filter is provided, will return background tasks from the last week.
 
-        :param project: Project name (defaults to mlrun.config.config.default_project).
+        :param project: Project name (defaults to mlrun.mlconf.default_project).
         :param state:   List only background tasks whose state is specified.
         :param created_from: Filter by background task created time in ``[created_from, created_to]``.
         :param created_to:  Filter by background task created time in ``[created_from, created_to]``.
@@ -3453,8 +3450,8 @@ class HTTPRunDB(RunDBInterface):
         source: Optional[str] = None,
         run_name: Optional[str] = None,
         namespace: Optional[str] = None,
-        notifications: list[mlrun.model.Notification] = None,
-    ) -> mlrun.common.schemas.WorkflowResponse:
+        notifications: typing.List[mlrun.model.Notification] = None,
+    ):
         """
         Submitting workflow for a remote execution.
 

mlrun/execution.py

@@ -559,9 +559,9 @@ class MLClientCtx(object):
             for k, v in get_in(task, ["status", "results"], {}).items():
                 self._results[k] = v
             for artifact in get_in(task, ["status", run_keys.artifacts], []):
-                self._artifacts_manager.artifacts[artifact["metadata"]["key"]] = (
-                    artifact
-                )
+                self._artifacts_manager.artifacts[
+                    artifact["metadata"]["key"]
+                ] = artifact
                 self._artifacts_manager.link_artifact(
                     self.project,
                     self.name,

mlrun/frameworks/tf_keras/callbacks/logging_callback.py

@@ -389,9 +389,9 @@ class LoggingCallback(Callback):
         ):
             try:
                 self._get_hyperparameter(key_chain=learning_rate_key_chain)
-                self._dynamic_hyperparameters_keys[learning_rate_key] = (
-                    learning_rate_key_chain
-                )
+                self._dynamic_hyperparameters_keys[
+                    learning_rate_key
+                ] = learning_rate_key_chain
             except (KeyError, IndexError, ValueError):
                 pass
 

mlrun/frameworks/tf_keras/model_handler.py

@@ -263,13 +263,13 @@ class TFKerasModelHandler(DLModelHandler):
         # Update the paths and log artifacts if context is available:
         if self._weights_file is not None:
             if self._context is not None:
-                artifacts[self._get_weights_file_artifact_name()] = (
-                    self._context.log_artifact(
-                        self._weights_file,
-                        local_path=self._weights_file,
-                        artifact_path=output_path,
-                        db_key=False,
-                    )
+                artifacts[
+                    self._get_weights_file_artifact_name()
+                ] = self._context.log_artifact(
+                    self._weights_file,
+                    local_path=self._weights_file,
+                    artifact_path=output_path,
+                    db_key=False,
                 )
 
         return artifacts if self._context is not None else None

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