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

mlrun/datastore/sources.py

@@ -62,11 +62,6 @@ class BaseSourceDriver(DataSource):
     def to_step(self, key_field=None, time_field=None, context=None):
         import storey
 
-        if not self.support_storey:
-            raise mlrun.errors.MLRunRuntimeError(
-                f"{type(self).__name__} does not support storey engine"
-            )
-
         return storey.SyncEmitSource(context=context)
 
     def get_table_object(self):
@@ -251,6 +246,7 @@ class ParquetSource(BaseSourceDriver):
         start_time: Optional[Union[datetime, str]] = None,
         end_time: Optional[Union[datetime, str]] = None,
     ):
+
         super().__init__(
             name,
             path,
@@ -380,15 +376,6 @@ class BigQuerySource(BaseSourceDriver):
             raise mlrun.errors.MLRunInvalidArgumentError(
                 "cannot specify both table and query args"
             )
-        # Otherwise, the client library does not fully respect the limit
-        if (
-            max_results_for_table
-            and chunksize
-            and max_results_for_table % chunksize != 0
-        ):
-            raise mlrun.errors.MLRunInvalidArgumentError(
-                "max_results_for_table must be a multiple of chunksize"
-            )
         attrs = {
             "query": query,
             "table": table,
@@ -408,6 +395,7 @@ class BigQuerySource(BaseSourceDriver):
             start_time=start_time,
             end_time=end_time,
         )
+        self._rows_iterator = None
 
     def _get_credentials_string(self):
         gcp_project = self.attributes.get("gcp_project", None)
@@ -450,28 +438,35 @@ class BigQuerySource(BaseSourceDriver):
         if query:
             query_job = bqclient.query(query)
 
-            rows_iterator = query_job.result(page_size=chunksize)
+            self._rows_iterator = query_job.result(page_size=chunksize)
+            dtypes = schema_to_dtypes(self._rows_iterator.schema)
+            if chunksize:
+                # passing bqstorage_client greatly improves performance
+                return self._rows_iterator.to_dataframe_iterable(
+                    bqstorage_client=BigQueryReadClient(), dtypes=dtypes
+                )
+            else:
+                return self._rows_iterator.to_dataframe(dtypes=dtypes)
         elif table:
             table = self.attributes.get("table")
             max_results = self.attributes.get("max_results")
 
-            rows_iterator = bqclient.list_rows(
+            rows = bqclient.list_rows(
                 table, page_size=chunksize, max_results=max_results
             )
+            dtypes = schema_to_dtypes(rows.schema)
+            if chunksize:
+                # passing bqstorage_client greatly improves performance
+                return rows.to_dataframe_iterable(
+                    bqstorage_client=BigQueryReadClient(), dtypes=dtypes
+                )
+            else:
+                return rows.to_dataframe(dtypes=dtypes)
         else:
             raise mlrun.errors.MLRunInvalidArgumentError(
                 "table or query args must be specified"
             )
 
-        dtypes = schema_to_dtypes(rows_iterator.schema)
-        if chunksize:
-            # passing bqstorage_client greatly improves performance
-            return rows_iterator.to_dataframe_iterable(
-                bqstorage_client=BigQueryReadClient(), dtypes=dtypes
-            )
-        else:
-            return rows_iterator.to_dataframe(dtypes=dtypes)
-
     def is_iterator(self):
         return bool(self.attributes.get("chunksize"))
 

mlrun/datastore/store_resources.py

@@ -81,7 +81,7 @@ class ResourceCache:
             endpoint, uri = parse_path(uri)
             self._tabels[uri] = Table(
                 uri,
-                V3ioDriver(webapi=endpoint or mlrun.mlconf.v3io_api),
+                V3ioDriver(webapi=endpoint),
                 flush_interval_secs=mlrun.mlconf.feature_store.flush_interval,
             )
             return self._tabels[uri]

mlrun/datastore/targets.py

@@ -15,7 +15,6 @@ import ast
 import datetime
 import os
 import random
-import sys
 import time
 from collections import Counter
 from copy import copy
@@ -526,8 +525,8 @@ class BaseStoreTarget(DataTargetBase):
                     ("minute", "%M"),
                 ]:
                     partition_cols.append(unit)
-                    target_df[unit] = pd.DatetimeIndex(target_df[timestamp_key]).format(
-                        date_format=fmt
+                    target_df[unit] = getattr(
+                        pd.DatetimeIndex(target_df[timestamp_key]), unit
                     )
                     if unit == time_partitioning_granularity:
                         break
@@ -1051,11 +1050,24 @@ class NoSqlBaseTarget(BaseStoreTarget):
             **self.attributes,
         )
 
-    def prepare_spark_df(self, df, key_columns):
-        raise NotImplementedError()
-
     def get_spark_options(self, key_column=None, timestamp_key=None, overwrite=True):
-        raise NotImplementedError()
+        spark_options = {
+            "path": store_path_to_spark(self.get_target_path()),
+            "format": "io.iguaz.v3io.spark.sql.kv",
+        }
+        if isinstance(key_column, list) and len(key_column) >= 1:
+            if len(key_column) > 2:
+                raise mlrun.errors.MLRunInvalidArgumentError(
+                    f"Spark supports maximun of 2 keys and {key_column} are provided"
+                )
+            spark_options["key"] = key_column[0]
+            if len(key_column) > 1:
+                spark_options["sorting-key"] = key_column[1]
+        else:
+            spark_options["key"] = key_column
+        if not overwrite:
+            spark_options["columnUpdate"] = True
+        return spark_options
 
     def get_dask_options(self):
         return {"format": "csv"}
@@ -1063,6 +1075,15 @@ class NoSqlBaseTarget(BaseStoreTarget):
     def as_df(self, columns=None, df_module=None, **kwargs):
         raise NotImplementedError()
 
+    def prepare_spark_df(self, df, key_columns):
+        import pyspark.sql.functions as funcs
+
+        for col_name, col_type in df.dtypes:
+            if col_type.startswith("decimal("):
+                # V3IO does not support this level of precision
+                df = df.withColumn(col_name, funcs.col(col_name).cast("double"))
+        return df
+
     def write_dataframe(
         self, df, key_column=None, timestamp_key=None, chunk_id=0, **kwargs
     ):
@@ -1102,52 +1123,10 @@ class NoSqlTarget(NoSqlBaseTarget):
         endpoint, uri = parse_path(self.get_target_path())
         return Table(
             uri,
-            V3ioDriver(webapi=endpoint or mlrun.mlconf.v3io_api),
+            V3ioDriver(webapi=endpoint),
             flush_interval_secs=mlrun.mlconf.feature_store.flush_interval,
         )
 
-    def get_spark_options(self, key_column=None, timestamp_key=None, overwrite=True):
-        spark_options = {
-            "path": store_path_to_spark(self.get_target_path()),
-            "format": "io.iguaz.v3io.spark.sql.kv",
-        }
-        if isinstance(key_column, list) and len(key_column) >= 1:
-            spark_options["key"] = key_column[0]
-            if len(key_column) > 2:
-                spark_options["sorting-key"] = "_spark_object_name"
-            if len(key_column) == 2:
-                spark_options["sorting-key"] = key_column[1]
-        else:
-            spark_options["key"] = key_column
-        if not overwrite:
-            spark_options["columnUpdate"] = True
-        return spark_options
-
-    def prepare_spark_df(self, df, key_columns):
-        from pyspark.sql.functions import col
-
-        spark_udf_directory = os.path.dirname(os.path.abspath(__file__))
-        sys.path.append(spark_udf_directory)
-        try:
-            import spark_udf
-
-            df.rdd.context.addFile(spark_udf.__file__)
-
-            for col_name, col_type in df.dtypes:
-                if col_type.startswith("decimal("):
-                    # V3IO does not support this level of precision
-                    df = df.withColumn(col_name, col(col_name).cast("double"))
-            if len(key_columns) > 2:
-                return df.withColumn(
-                    "_spark_object_name",
-                    spark_udf.hash_and_concat_v3io_udf(
-                        *[col(c) for c in key_columns[1:]]
-                    ),
-                )
-        finally:
-            sys.path.remove(spark_udf_directory)
-        return df
-
 
 class RedisNoSqlTarget(NoSqlBaseTarget):
     kind = TargetTypes.redisnosql
@@ -1207,23 +1186,11 @@ class RedisNoSqlTarget(NoSqlBaseTarget):
         return endpoint
 
     def prepare_spark_df(self, df, key_columns):
-        from pyspark.sql.functions import col
+        from pyspark.sql.functions import udf
+        from pyspark.sql.types import StringType
 
-        spark_udf_directory = os.path.dirname(os.path.abspath(__file__))
-        sys.path.append(spark_udf_directory)
-        try:
-            import spark_udf
-
-            df.rdd.context.addFile(spark_udf.__file__)
-
-            df = df.withColumn(
-                "_spark_object_name",
-                spark_udf.hash_and_concat_redis_udf(*[col(c) for c in key_columns]),
-            )
-        finally:
-            sys.path.remove(spark_udf_directory)
-
-        return df
+        udf1 = udf(lambda x: str(x) + "}:static", StringType())
+        return df.withColumn("_spark_object_name", udf1(key_columns[0]))
 
 
 class StreamTarget(BaseStoreTarget):
@@ -1257,7 +1224,7 @@ class StreamTarget(BaseStoreTarget):
             graph_shape="cylinder",
             class_name="storey.StreamTarget",
             columns=column_list,
-            storage=V3ioDriver(webapi=endpoint or mlrun.mlconf.v3io_api),
+            storage=V3ioDriver(webapi=endpoint),
             stream_path=uri,
             **self.attributes,
         )

mlrun/datastore/utils.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-import typing
-from urllib.parse import parse_qs, urlparse
+from urllib.parse import urlparse
 
 
 def store_path_to_spark(path):
@@ -37,32 +36,11 @@ def store_path_to_spark(path):
     return path
 
 
-def parse_kafka_url(
-    url: str, bootstrap_servers: typing.List = None
-) -> typing.Tuple[str, typing.List]:
-    """Generating Kafka topic and adjusting a list of bootstrap servers.
-
-    :param url:               URL path to parse using urllib.parse.urlparse.
-    :param bootstrap_servers: List of bootstrap servers for the kafka brokers.
-
-    :return: A tuple of:
-         [0] = Kafka topic value
-         [1] = List of bootstrap servers
-    """
+def parse_kafka_url(url, bootstrap_servers=None):
     bootstrap_servers = bootstrap_servers or []
-
-    # Parse the provided URL into six components according to the general structure of a URL
     url = urlparse(url)
-
-    # Add the network location to the bootstrap servers list
     if url.netloc:
         bootstrap_servers = [url.netloc] + bootstrap_servers
-
-    # Get the topic value from the parsed url
-    query_dict = parse_qs(url.query)
-    if "topic" in query_dict:
-        topic = query_dict["topic"][0]
-    else:
-        topic = url.path
-        topic = topic.lstrip("/")
+    topic = url.path
+    topic = topic.lstrip("/")
     return topic, bootstrap_servers

mlrun/db/base.py

@@ -17,8 +17,8 @@ import warnings
 from abc import ABC, abstractmethod
 from typing import List, Optional, Union
 
-import mlrun.model_monitoring.model_endpoint
 from mlrun.api import schemas
+from mlrun.api.schemas import ModelEndpoint
 
 
 class RunDBError(Exception):
@@ -479,9 +479,7 @@ class RunDBInterface(ABC):
         self,
         project: str,
         endpoint_id: str,
-        model_endpoint: Union[
-            mlrun.model_monitoring.model_endpoint.ModelEndpoint, dict
-        ],
+        model_endpoint: ModelEndpoint,
     ):
         pass
 

mlrun/db/filedb.py

@@ -14,7 +14,6 @@
 
 import json
 import pathlib
-import typing
 from datetime import datetime, timedelta, timezone
 from os import listdir, makedirs, path, remove, scandir
 from typing import List, Optional, Union
@@ -24,9 +23,9 @@ from dateutil.parser import parse as parse_time
 
 import mlrun.api.schemas
 import mlrun.errors
-import mlrun.model_monitoring.model_endpoint
 
 from ..api import schemas
+from ..api.schemas import ModelEndpoint
 from ..config import config
 from ..datastore import store_manager
 from ..lists import ArtifactList, RunList
@@ -60,8 +59,7 @@ class FileRunDB(RunDBInterface):
         self.dirpath = dirpath
         self._datastore = None
         self._subpath = None
-        self._secrets: typing.Optional[mlrun.secrets.SecretsStore] = None
-        self._projects = {}
+        self._secrets = None
         makedirs(self.schedules_dir, exist_ok=True)
 
     def connect(self, secrets=None):
@@ -554,10 +552,7 @@ class FileRunDB(RunDBInterface):
         self,
         project: mlrun.api.schemas.Project,
     ) -> mlrun.api.schemas.Project:
-        if isinstance(project, dict):
-            project = mlrun.api.schemas.Project(**project)
-        self._projects[project.metadata.name] = project
-        return project
+        raise NotImplementedError()
 
     @property
     def schedules_dir(self):
@@ -743,8 +738,7 @@ class FileRunDB(RunDBInterface):
         provider: str = mlrun.api.schemas.SecretProviderName.kubernetes.value,
         secrets: dict = None,
     ):
-        for key, value in secrets.items():
-            self._secrets._secrets[key] = value
+        raise NotImplementedError()
 
     def list_project_secrets(
         self,
@@ -786,9 +780,7 @@ class FileRunDB(RunDBInterface):
         self,
         project: str,
         endpoint_id: str,
-        model_endpoint: Union[
-            mlrun.model_monitoring.model_endpoint.ModelEndpoint, dict
-        ],
+        model_endpoint: ModelEndpoint,
     ):
         raise NotImplementedError()
 

mlrun/db/httpdb.py

@@ -27,11 +27,11 @@ import requests
 import semver
 
 import mlrun
-import mlrun.model_monitoring.model_endpoint
 import mlrun.projects
 from mlrun.api import schemas
 from mlrun.errors import MLRunInvalidArgumentError, err_to_str
 
+from ..api.schemas import ModelEndpoint
 from ..artifacts import Artifact
 from ..config import config
 from ..feature_store import FeatureSet, FeatureVector
@@ -1425,9 +1425,9 @@ class HTTPRunDB(RunDBInterface):
         :param page_size: Size of a single page when applying pagination.
         """
 
-        if project != "*" and (page_token or page_size):
+        if project != "*" and (page_token or page_size or sort_by):
             raise mlrun.errors.MLRunInvalidArgumentError(
-                "Filtering by project can not be used together with pagination"
+                "Filtering by project can not be used together with pagination, or sorting"
             )
         params = {
             "namespace": namespace,
@@ -2533,9 +2533,7 @@ class HTTPRunDB(RunDBInterface):
         self,
         project: str,
         endpoint_id: str,
-        model_endpoint: Union[
-            mlrun.model_monitoring.model_endpoint.ModelEndpoint, dict
-        ],
+        model_endpoint: ModelEndpoint,
     ):
         """
         Creates a DB record with the given model_endpoint record.
@@ -2545,16 +2543,11 @@ class HTTPRunDB(RunDBInterface):
         :param model_endpoint: An object representing the model endpoint.
         """
 
-        if isinstance(
-            model_endpoint, mlrun.model_monitoring.model_endpoint.ModelEndpoint
-        ):
-            model_endpoint = model_endpoint.to_dict()
-
         path = f"projects/{project}/model-endpoints/{endpoint_id}"
         self.api_call(
             method="POST",
             path=path,
-            body=dict_to_json(model_endpoint),
+            body=model_endpoint.json(),
         )
 
     def delete_model_endpoint(
@@ -2563,7 +2556,7 @@ class HTTPRunDB(RunDBInterface):
         endpoint_id: str,
     ):
         """
-        Deletes the DB record of a given model endpoint, project and endpoint_id are used for lookup
+        Deletes the KV record of a given model endpoint, project and endpoint_id are used for lookup
 
         :param project: The name of the project
         :param endpoint_id: The id of the endpoint
@@ -2586,15 +2579,13 @@ class HTTPRunDB(RunDBInterface):
         metrics: Optional[List[str]] = None,
         top_level: bool = False,
         uids: Optional[List[str]] = None,
-    ) -> List[mlrun.model_monitoring.model_endpoint.ModelEndpoint]:
+    ) -> schemas.ModelEndpointList:
         """
-        Returns a list of `ModelEndpoint` objects. Each `ModelEndpoint` object represents the current state of a
-        model endpoint. This functions supports filtering by the following parameters:
+        Returns a list of ModelEndpointState objects. Each object represents the current state of a model endpoint.
+        This functions supports filtering by the following parameters:
         1) model
         2) function
         3) labels
-        4) top level
-        5) uids
         By default, when no filters are applied, all available endpoints for the given project will be listed.
 
         In addition, this functions provides a facade for listing endpoint related metrics. This facade is time-based
@@ -2604,8 +2595,8 @@ class HTTPRunDB(RunDBInterface):
         :param project: The name of the project
         :param model: The name of the model to filter by
         :param function: The name of the function to filter by
-        :param labels: A list of labels to filter by. Label filters work by either filtering a specific value of a
-         label (i.e. list("key=value")) or by looking for the existence of a given key (i.e. "key")
+        :param labels: A list of labels to filter by. Label filters work by either filtering a specific value of a label
+            (i.e. list("key==value")) or by looking for the existence of a given key (i.e. "key")
         :param metrics: A list of metrics to return for each endpoint, read more in 'TimeMetric'
         :param start: The start time of the metrics. Can be represented by a string containing an RFC 3339
                                  time, a Unix timestamp in milliseconds, a relative time (`'now'` or
@@ -2616,14 +2607,10 @@ class HTTPRunDB(RunDBInterface):
                                  `'now-[0-9]+[mhd]'`, where `m` = minutes, `h` = hours, and `'d'` =
                                  days), or 0 for the earliest time.
         :param top_level: if true will return only routers and endpoint that are NOT children of any router
-        :param uids: if passed will return a list `ModelEndpoint` object with uid in uids
+        :param uids: if passed will return ModelEndpointList of endpoints with uid in uids
         """
 
         path = f"projects/{project}/model-endpoints"
-
-        if labels and isinstance(labels, dict):
-            labels = [f"{key}={value}" for key, value in labels.items()]
-
         response = self.api_call(
             method="GET",
             path=path,
@@ -2638,15 +2625,7 @@ class HTTPRunDB(RunDBInterface):
                 "uid": uids,
             },
         )
-
-        # Generate a list of a model endpoint dictionaries
-        model_endpoints = response.json()["endpoints"]
-        if model_endpoints:
-            return [
-                mlrun.model_monitoring.model_endpoint.ModelEndpoint.from_dict(obj)
-                for obj in model_endpoints
-            ]
-        return []
+        return schemas.ModelEndpointList(**response.json())
 
     def get_model_endpoint(
         self,
@@ -2656,29 +2635,21 @@ class HTTPRunDB(RunDBInterface):
         end: Optional[str] = None,
         metrics: Optional[List[str]] = None,
         feature_analysis: bool = False,
-    ) -> mlrun.model_monitoring.model_endpoint.ModelEndpoint:
-        """
-        Returns a single `ModelEndpoint` object with additional metrics and feature related data.
-
-        :param project:                    The name of the project
-        :param endpoint_id:                The unique id of the model endpoint.
-        :param start:                      The start time of the metrics. Can be represented by a string containing an
-                                           RFC 3339 time, a Unix timestamp in milliseconds, a relative time (`'now'` or
-                                           `'now-[0-9]+[mhd]'`, where `m` = minutes, `h` = hours, and `'d'` = days), or
-                                           0 for the earliest time.
-        :param end:                        The end time of the metrics. Can be represented by a string containing an
-                                           RFC 3339 time, a Unix timestamp in milliseconds, a relative time (`'now'` or
-                                           `'now-[0-9]+[mhd]'`, where `m` = minutes, `h` = hours, and `'d'` = days), or
-                                           0 for the earliest time.
-        :param metrics:                    A list of metrics to return for the model endpoint. There are pre-defined
-                                           metrics for model endpoints such as predictions_per_second and
-                                           latency_avg_5m but also custom metrics defined by the user. Please note that
-                                           these metrics are stored in the time series DB and the results will be
-                                           appeared under model_endpoint.spec.metrics.
-        :param feature_analysis:           When True, the base feature statistics and current feature statistics will
-                                           be added to the output of the resulting object.
-
-        :return: A `ModelEndpoint` object.
+    ) -> schemas.ModelEndpoint:
+        """
+        Returns a ModelEndpoint object with additional metrics and feature related data.
+
+        :param project: The name of the project
+        :param endpoint_id: The id of the model endpoint
+        :param metrics: A list of metrics to return for each endpoint, read more in 'TimeMetric'
+        :param start: The start time of the metrics. Can be represented by a string containing an RFC 3339
+                      time, a Unix timestamp in milliseconds, a relative time (`'now'` or `'now-[0-9]+[mhd]'`,
+                      where `m` = minutes, `h` = hours, and `'d'` = days), or 0 for the earliest time.
+        :param end: The end time of the metrics. Can be represented by a string containing an RFC 3339
+                    time, a Unix timestamp in milliseconds, a relative time (`'now'` or `'now-[0-9]+[mhd]'`,
+                    where `m` = minutes, `h` = hours, and `'d'` = days), or 0 for the earliest time.
+        :param feature_analysis: When True, the base feature statistics and current feature statistics will be added to
+            the output of the resulting object
         """
 
         path = f"projects/{project}/model-endpoints/{endpoint_id}"
@@ -2692,10 +2663,7 @@ class HTTPRunDB(RunDBInterface):
                 "feature_analysis": feature_analysis,
             },
         )
-
-        return mlrun.model_monitoring.model_endpoint.ModelEndpoint.from_dict(
-            response.json()
-        )
+        return schemas.ModelEndpoint(**response.json())
 
     def patch_model_endpoint(
         self,
@@ -2709,9 +2677,9 @@ class HTTPRunDB(RunDBInterface):
         :param project: The name of the project.
         :param endpoint_id: The id of the endpoint.
         :param attributes: Dictionary of attributes that will be used for update the model endpoint. The keys
-                           of this dictionary should exist in the target table. Note that the values should be
-                           from type string or from a valid numerical type such as int or float.
-                            More details about the model endpoint available attributes can be found under
+                           of this dictionary should exist in the target table. The values should be
+                           from type string or from a valid numerical type such as int or float. More details
+                           about the model endpoint available attributes can be found under
                            :py:class:`~mlrun.api.schemas.ModelEndpoint`.
 
                            Example::

mlrun/db/sqldb.py

@@ -16,7 +16,6 @@ import datetime
 from typing import List, Optional, Union
 
 import mlrun.api.schemas
-import mlrun.model_monitoring.model_endpoint
 from mlrun.api.db.base import DBError
 from mlrun.api.db.sqldb.db import SQLDB as SQLAPIDB
 from mlrun.api.db.sqldb.session import create_session
@@ -30,6 +29,7 @@ from mlrun.api.db.sqldb.session import create_session
 # will be httpdb to that same api service) we have this class which is kind of a proxy between the RunDB interface to
 # the api service's DB interface
 from ..api import schemas
+from ..api.schemas import ModelEndpoint
 from .base import RunDBError, RunDBInterface
 
 
@@ -773,9 +773,7 @@ class SQLDB(RunDBInterface):
         self,
         project: str,
         endpoint_id: str,
-        model_endpoint: Union[
-            mlrun.model_monitoring.model_endpoint.ModelEndpoint, dict
-        ],
+        model_endpoint: ModelEndpoint,
     ):
         raise NotImplementedError()
 

mlrun/errors.py

@@ -179,10 +179,6 @@ class MLRunInternalServerError(MLRunHTTPStatusError):
     error_status_code = HTTPStatus.INTERNAL_SERVER_ERROR.value
 
 
-class MLRunServiceUnavailableError(MLRunHTTPStatusError):
-    error_status_code = HTTPStatus.SERVICE_UNAVAILABLE.value
-
-
 class MLRunRuntimeError(MLRunHTTPStatusError, RuntimeError):
     error_status_code = HTTPStatus.INTERNAL_SERVER_ERROR.value
 
@@ -217,5 +213,4 @@ STATUS_ERRORS = {
     HTTPStatus.CONFLICT.value: MLRunConflictError,
     HTTPStatus.PRECONDITION_FAILED.value: MLRunPreconditionFailedError,
     HTTPStatus.INTERNAL_SERVER_ERROR.value: MLRunInternalServerError,
-    HTTPStatus.SERVICE_UNAVAILABLE.value: MLRunServiceUnavailableError,
 }

mlrun/execution.py

@@ -20,7 +20,6 @@ from typing import List, Union
 
 import numpy as np
 import yaml
-from dateutil import parser
 
 import mlrun
 from mlrun.artifacts import ModelArtifact
@@ -315,7 +314,6 @@ class MLClientCtx(object):
 
         start = get_in(attrs, "status.start_time")
         if start:
-            start = parser.parse(start) if isinstance(start, str) else start
             self._start_time = start
         self._state = "running"
         if store_run: