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

mlrun/feature_store/feature_vector.py

@@ -741,6 +741,64 @@ class FeatureVector(ModelObj):
         spark_service: str = None,
         timestamp_for_filtering: Union[str, dict[str, str]] = None,
     ):
+        """retrieve offline feature vector results
+
+        specify a feature vector object/uri and retrieve the desired features, their metadata
+        and statistics. returns :py:class:`~mlrun.feature_store.OfflineVectorResponse`,
+        results can be returned as a dataframe or written to a target
+
+        The start_time and end_time attributes allow filtering the data to a given time range, they accept
+        string values or pandas `Timestamp` objects, string values can also be relative, for example:
+        "now", "now - 1d2h", "now+5m", where a valid pandas Timedelta string follows the verb "now",
+        for time alignment you can use the verb "floor" e.g. "now -1d floor 1H" will align the time to the last hour
+        (the floor string is passed to pandas.Timestamp.floor(), can use D, H, T, S for day, hour, min, sec alignment).
+        Another option to filter the data is by the `query` argument - can be seen in the example.
+        example::
+
+            features = [
+                "stock-quotes.bid",
+                "stock-quotes.asks_sum_5h",
+                "stock-quotes.ask as mycol",
+                "stocks.*",
+            ]
+            vector = FeatureVector(features=features)
+            vector.get_offline_features(entity_rows=trades, entity_timestamp_column="time", query="ticker in ['GOOG']
+              and bid>100")
+            print(resp.to_dataframe())
+            print(vector.get_stats_table())
+            resp.to_parquet("./out.parquet")
+
+        :param entity_rows:             dataframe with entity rows to join with
+        :param target:                  where to write the results to
+        :param drop_columns:            list of columns to drop from the final result
+        :param entity_timestamp_column: timestamp column name in the entity rows dataframe. can be specified
+                                        only if param entity_rows was specified.
+        :param run_config:              function and/or run configuration
+                                        see :py:class:`~mlrun.feature_store.RunConfig`
+        :param start_time:              datetime, low limit of time needed to be filtered. Optional.
+        :param end_time:                datetime, high limit of time needed to be filtered. Optional.
+        :param with_indexes:            Return vector with/without the entities and the timestamp_key of the feature
+                                        sets and with/without entity_timestamp_column and timestamp_for_filtering
+                                        columns. This property can be specified also in the feature vector spec
+                                        (feature_vector.spec.with_indexes)
+                                        (default False)
+        :param update_stats:            update features statistics from the requested feature sets on the vector.
+                                        (default False).
+        :param engine:                  processing engine kind ("local", "dask", or "spark")
+        :param engine_args:             kwargs for the processing engine
+        :param query:                   The query string used to filter rows on the output
+        :param spark_service:           Name of the spark service to be used (when using a remote-spark runtime)
+        :param order_by:                Name or list of names to order by. The name or the names in the list can be the
+                                        feature name or the alias of the feature you pass in the feature list.
+        :param timestamp_for_filtering: name of the column to filter by, can be str for all the feature sets or a
+                                        dictionary ({<feature set name>: <timestamp column name>, ...})
+                                        that indicates the timestamp column name for each feature set. Optional.
+                                        By default, the filter executes on the timestamp_key of each feature set.
+                                        Note: the time filtering is performed on each feature set before the
+                                        merge process using start_time and end_time params.
+
+        """
+
         return mlrun.feature_store.api._get_offline_features(
             self,
             entity_rows,
@@ -768,6 +826,68 @@ class FeatureVector(ModelObj):
         update_stats: bool = False,
         entity_keys: list[str] = None,
     ):
+        """initialize and return online feature vector service api,
+        returns :py:class:`~mlrun.feature_store.OnlineVectorService`
+
+        :**usage**:
+            There are two ways to use the function:
+
+            1. As context manager
+
+                Example::
+
+                    with vector_uri.get_online_feature_service() as svc:
+                        resp = svc.get([{"ticker": "GOOG"}, {"ticker": "MSFT"}])
+                        print(resp)
+                        resp = svc.get([{"ticker": "AAPL"}], as_list=True)
+                        print(resp)
+
+                Example with imputing::
+
+                    with vector_uri.get_online_feature_service(entity_keys=['id'],
+                                                    impute_policy={"*": "$mean", "amount": 0)) as svc:
+                        resp = svc.get([{"id": "C123487"}])
+
+            2. as simple function, note that in that option you need to close the session.
+
+                Example::
+
+                    svc = vector_uri.get_online_feature_service(entity_keys=['ticker'])
+                    try:
+                        resp = svc.get([{"ticker": "GOOG"}, {"ticker": "MSFT"}])
+                        print(resp)
+                        resp = svc.get([{"ticker": "AAPL"}], as_list=True)
+                        print(resp)
+
+                    finally:
+                        svc.close()
+
+                Example with imputing::
+
+                    svc = vector_uri.get_online_feature_service(entity_keys=['id'],
+                                                    impute_policy={"*": "$mean", "amount": 0))
+                    try:
+                        resp = svc.get([{"id": "C123487"}])
+                    except Exception as e:
+                        handling exception...
+                    finally:
+                        svc.close()
+
+        :param run_config:          function and/or run configuration for remote jobs/services
+        :param impute_policy:       a dict with `impute_policy` per feature, the dict key is the feature name and the
+                                    dict value indicate which value will be used in case the feature is NaN/empty, the
+                                    replaced value can be fixed number for constants or $mean, $max, $min, $std, $count
+                                    for statistical values.
+                                    "*" is used to specify the default for all features, example: `{"*": "$mean"}`
+        :param fixed_window_type:   determines how to query the fixed window values which were previously inserted by
+                                    ingest
+        :param update_stats:        update features statistics from the requested feature sets on the vector.
+                                    Default: False.
+        :param entity_keys:         Entity list of the first feature_set in the vector.
+                                    The indexes that are used to query the online service.
+        :return:                    Initialize the `OnlineVectorService`.
+                                    Will be used in subclasses where `support_online=True`.
+        """
         return mlrun.feature_store.api._get_online_feature_service(
             self,
             run_config,

mlrun/feature_store/steps.py

@@ -92,8 +92,6 @@ class MLRunStep(MapClass):
 
 
 class FeaturesetValidator(StepToDict, MLRunStep):
-    """Validate feature values according to the feature set validation policy"""
-
     def __init__(self, featureset=None, columns=None, name=None, **kwargs):
         """Validate feature values according to the feature set validation policy
 
@@ -152,8 +150,6 @@ class FeaturesetValidator(StepToDict, MLRunStep):
 
 
 class MapValues(StepToDict, MLRunStep):
-    """Map column values to new values"""
-
     def __init__(
         self,
         mapping: dict[str, dict[Union[str, int, bool], Any]],
@@ -510,15 +506,13 @@ class OneHotEncoder(StepToDict, MLRunStep):
 
 
 class DateExtractor(StepToDict, MLRunStep):
-    """Date Extractor allows you to extract a date-time component"""
-
     def __init__(
         self,
         parts: Union[dict[str, str], list[str]],
         timestamp_col: str = None,
         **kwargs,
     ):
-        """Date Extractor extract a date-time component into new columns
+        """Date Extractor extracts a date-time component into new columns
 
         The extracted date part will appear as `<timestamp_col>_<date_part>` feature.
 
@@ -629,8 +623,6 @@ class DateExtractor(StepToDict, MLRunStep):
 
 
 class SetEventMetadata(MapClass):
-    """Set the event metadata (id and key) from the event body"""
-
     def __init__(
         self,
         id_path: Optional[str] = None,

mlrun/features.py

@@ -65,8 +65,6 @@ class Entity(ModelObj):
 
 
 class Feature(ModelObj):
-    """data feature"""
-
     _dict_fields = [
         "name",
         "description",

mlrun/k8s_utils.py

@@ -17,6 +17,7 @@ import kubernetes.client
 
 import mlrun.common.schemas
 import mlrun.errors
+import mlrun.utils.regex
 
 from .config import config as mlconfig
 
@@ -130,3 +131,53 @@ def sanitize_label_value(value: str) -> str:
     :return:      string fully compliant with k8s label value expectations
     """
     return re.sub(r"([^a-zA-Z0-9_.-]|^[^a-zA-Z0-9]|[^a-zA-Z0-9]$)", "-", value[:63])
+
+
+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}'",
+        key,
+        mlrun.utils.regex.k8s_character_limit,
+    )
+
+    parts = key.split("/")
+    if len(parts) == 1:
+        name = parts[0]
+    elif len(parts) == 2:
+        prefix, name = parts
+        if len(prefix) == 0:
+            raise mlrun.errors.MLRunInvalidArgumentError(
+                "Label key prefix cannot be empty"
+            )
+
+        # prefix must adhere dns_1123_subdomain
+        mlrun.utils.helpers.verify_field_regex(
+            f"Project.metadata.labels.'{key}'",
+            prefix,
+            mlrun.utils.regex.dns_1123_subdomain,
+        )
+    else:
+        raise mlrun.errors.MLRunInvalidArgumentError(
+            "Label key can only contain one '/'"
+        )
+
+    mlrun.utils.helpers.verify_field_regex(
+        f"project.metadata.labels.'{key}'",
+        name,
+        mlrun.utils.regex.qualified_name,
+    )
+
+
+def verify_label_value(value, label_key):
+    mlrun.utils.helpers.verify_field_regex(
+        f"project.metadata.labels.'{label_key}'",
+        value,
+        mlrun.utils.regex.label_value,
+    )

mlrun/model_monitoring/stream_processing.py

@@ -745,18 +745,12 @@ class ProcessEndpointEvent(mlrun.feature_store.steps.MapClass):
         # in list of events. This list will be used as the body for the storey event.
         events = []
         for i, (feature, prediction) in enumerate(zip(features, predictions)):
-            # Validate that inputs are based on numeric values
-            if not self.is_valid(
-                endpoint_id,
-                self.is_list_of_numerics,
-                feature,
-                ["request", "inputs", f"[{i}]"],
-            ):
-                return None
-
             if not isinstance(prediction, list):
                 prediction = [prediction]
 
+            if not isinstance(feature, list):
+                feature = [feature]
+
             events.append(
                 {
                     EventFieldType.FUNCTION_URI: function_uri,
@@ -803,18 +797,6 @@ class ProcessEndpointEvent(mlrun.feature_store.steps.MapClass):
                 f"{self.last_request[endpoint_id]} - write to TSDB will be rejected"
             )
 
-    @staticmethod
-    def is_list_of_numerics(
-        field: list[typing.Union[int, float, dict, list]],
-        dict_path: list[str],
-    ):
-        if all(isinstance(x, int) or isinstance(x, float) for x in field):
-            return True
-        logger.error(
-            f"List does not consist of only numeric values: {field} [Event -> {','.join(dict_path)}]"
-        )
-        return False
-
     def resume_state(self, endpoint_id):
         # Make sure process is resumable, if process fails for any reason, be able to pick things up close to where we
         # left them

mlrun/projects/project.py

@@ -40,6 +40,7 @@ import mlrun.common.schemas.model_monitoring
 import mlrun.common.schemas.model_monitoring.constants as mm_constants
 import mlrun.db
 import mlrun.errors
+import mlrun.k8s_utils
 import mlrun.runtimes
 import mlrun.runtimes.pod
 import mlrun.runtimes.utils
@@ -579,24 +580,36 @@ def _run_project_setup(
 
 def _load_project_dir(context, name="", subpath=""):
     subpath_str = subpath or ""
-    fpath = path.join(context, subpath_str, "project.yaml")
+
+    # support both .yaml and .yml file extensions
+    project_file_path = path.join(context, subpath_str, "project.y*ml")
+    function_file_path = path.join(context, subpath_str, "function.y*ml")
     setup_file_path = path.join(context, subpath_str, "project_setup.py")
-    if path.isfile(fpath):
-        with open(fpath) as fp:
+
+    if project_files := glob.glob(project_file_path):
+        # if there are multiple project files, use the first one
+        project_file_path = project_files[0]
+        with open(project_file_path) as fp:
             data = fp.read()
             struct = yaml.load(data, Loader=yaml.FullLoader)
             project = _project_instance_from_struct(struct, name)
             project.spec.context = context
-
-    elif path.isfile(path.join(context, subpath_str, "function.yaml")):
-        func = import_function(path.join(context, subpath_str, "function.yaml"))
+    elif function_files := glob.glob(function_file_path):
+        function_path = function_files[0]
+        func = import_function(function_path)
+        function_file_name = path.basename(path.normpath(function_path))
         project = MlrunProject.from_dict(
             {
                 "metadata": {
                     "name": func.metadata.project,
                 },
                 "spec": {
-                    "functions": [{"url": "function.yaml", "name": func.metadata.name}],
+                    "functions": [
+                        {
+                            "url": function_file_name,
+                            "name": func.metadata.name,
+                        },
+                    ],
                 },
             }
         )
@@ -693,6 +706,31 @@ class ProjectMetadata(ModelObj):
             return False
         return True
 
+    @staticmethod
+    def validate_project_labels(labels: dict, raise_on_failure: bool = True) -> bool:
+        """
+        This
+        https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#syntax-and-character-set
+        """
+
+        # no labels is a valid case
+        if not labels:
+            return True
+        if not isinstance(labels, dict):
+            raise mlrun.errors.MLRunInvalidArgumentError(
+                "Labels must be a dictionary of key-value pairs"
+            )
+        try:
+            for key, value in labels.items():
+                mlrun.k8s_utils.verify_label_key(key)
+                mlrun.k8s_utils.verify_label_value(value, label_key=key)
+
+        except mlrun.errors.MLRunInvalidArgumentError:
+            if raise_on_failure:
+                raise
+            return False
+        return True
+
 
 class ProjectSpec(ModelObj):
     def __init__(

mlrun/serving/remote.py

@@ -36,8 +36,6 @@ default_backoff_factor = 1
 
 
 class RemoteStep(storey.SendToHttp):
-    """class for calling remote endpoints"""
-
     def __init__(
         self,
         url: str,
@@ -240,8 +238,6 @@ class RemoteStep(storey.SendToHttp):
 
 
 class BatchHttpRequests(_ConcurrentJobExecution):
-    """class for calling remote endpoints in parallel"""
-
     def __init__(
         self,
         url: str = None,

mlrun/serving/routers.py

@@ -1111,7 +1111,7 @@ class EnrichmentModelRouter(ModelRouter):
         url_prefix: str = None,
         health_prefix: str = None,
         feature_vector_uri: str = "",
-        impute_policy: dict = {},
+        impute_policy: dict = None,
         **kwargs,
     ):
         """Model router with feature enrichment (from the feature store)
@@ -1156,13 +1156,17 @@ class EnrichmentModelRouter(ModelRouter):
         )
 
         self.feature_vector_uri = feature_vector_uri
-        self.impute_policy = impute_policy
+        self.impute_policy = impute_policy or {}
 
         self._feature_service = None
 
     def post_init(self, mode="sync"):
+        from ..feature_store import get_feature_vector
+
         super().post_init(mode)
-        self._feature_service = self.feature_vector.get_online_feature_service(
+        self._feature_service = get_feature_vector(
+            self.feature_vector_uri
+        ).get_online_feature_service(
             impute_policy=self.impute_policy,
         )
 
@@ -1191,7 +1195,7 @@ class EnrichmentVotingEnsemble(VotingEnsemble):
         executor_type: Union[ParallelRunnerModes, str] = ParallelRunnerModes.thread,
         prediction_col_name: str = None,
         feature_vector_uri: str = "",
-        impute_policy: dict = {},
+        impute_policy: dict = None,
         **kwargs,
     ):
         """Voting Ensemble with feature enrichment (from the feature store)
@@ -1298,13 +1302,17 @@ class EnrichmentVotingEnsemble(VotingEnsemble):
         )
 
         self.feature_vector_uri = feature_vector_uri
-        self.impute_policy = impute_policy
+        self.impute_policy = impute_policy or {}
 
         self._feature_service = None
 
     def post_init(self, mode="sync"):
+        from ..feature_store import get_feature_vector
+
         super().post_init(mode)
-        self._feature_service = self.feature_vector.get_online_feature_service(
+        self._feature_service = get_feature_vector(
+            self.feature_vector_uri
+        ).get_online_feature_service(
             impute_policy=self.impute_policy,
         )
 

mlrun/serving/states.py

@@ -1542,6 +1542,7 @@ def _init_async_objects(context, steps):
                     result_path=step.result_path,
                     name=step.name,
                     context=context,
+                    pass_context=step._inject_context,
                 )
             if (
                 respond_supported

mlrun/serving/v2_serving.py

@@ -29,8 +29,6 @@ from .utils import StepToDict, _extract_input_data, _update_result_body
 
 
 class V2ModelServer(StepToDict):
-    """base model serving class (v2), using similar API to KFServing v2 and Triton"""
-
     def __init__(
         self,
         context=None,
@@ -221,6 +219,8 @@ class V2ModelServer(StepToDict):
 
     def _pre_event_processing_actions(self, event, event_body, op):
         self._check_readiness(event)
+        if "_dict" in op:
+            event_body = self._inputs_to_list(event_body)
         request = self.preprocess(event_body, op)
         return self.validate(request, op)
 
@@ -237,7 +237,12 @@ class V2ModelServer(StepToDict):
         if not op and event.method != "GET":
             op = "infer"
 
-        if op == "predict" or op == "infer":
+        if (
+            op == "predict"
+            or op == "infer"
+            or op == "infer_dict"
+            or op == "predict_dict"
+        ):
             # predict operation
             request = self._pre_event_processing_actions(event, event_body, op)
             try:
@@ -378,6 +383,43 @@ class V2ModelServer(StepToDict):
         """model explain operation"""
         raise NotImplementedError()
 
+    def _inputs_to_list(self, request: dict) -> dict:
+        """
+        Convert the inputs from list of dictionary / dictionary to list of lists / list
+        where the internal list order is according to the ArtifactModel inputs.
+
+        :param request: event
+        :return: evnet body converting the inputs to be list of lists
+        """
+        if self.model_spec and self.model_spec.inputs:
+            input_order = [feature.name for feature in self.model_spec.inputs]
+        else:
+            raise mlrun.MLRunInvalidArgumentError(
+                "In order to use predict_dict or infer_dict operation you have to provide `model_path` "
+                "to the model server and to load it by `load()` function"
+            )
+        inputs = request.get("inputs")
+        try:
+            if isinstance(inputs, list) and all(
+                isinstance(item, dict) for item in inputs
+            ):
+                new_inputs = [
+                    [input_dict[key] for key in input_order] for input_dict in inputs
+                ]
+            elif isinstance(inputs, dict):
+                new_inputs = [inputs[key] for key in input_order]
+            else:
+                raise mlrun.MLRunInvalidArgumentError(
+                    "When using predict_dict or infer_dict operation the inputs must be "
+                    "of type `list[dict]` or `dict`"
+                )
+        except KeyError:
+            raise mlrun.MLRunInvalidArgumentError(
+                f"Input dictionary don't contain all the necessary input keys : {input_order}"
+            )
+        request["inputs"] = new_inputs
+        return request
+
 
 class _ModelLogPusher:
     def __init__(self, model, context, output_stream=None):

mlrun/utils/helpers.py

@@ -181,6 +181,8 @@ def verify_field_regex(
     log_message: str = "Field is malformed. Does not match required pattern",
     mode: mlrun.common.schemas.RegexMatchModes = mlrun.common.schemas.RegexMatchModes.all,
 ) -> bool:
+    # limit the error message
+    max_chars = 63
     for pattern in patterns:
         if not re.match(pattern, str(field_value)):
             log_func = logger.warn if raise_on_failure else logger.debug
@@ -193,7 +195,8 @@ def verify_field_regex(
             if mode == mlrun.common.schemas.RegexMatchModes.all:
                 if raise_on_failure:
                     raise mlrun.errors.MLRunInvalidArgumentError(
-                        f"Field '{field_name}' is malformed. '{field_value}' does not match required pattern: {pattern}"
+                        f"Field '{field_name[:max_chars]}' is malformed. '{field_value[:max_chars]}' "
+                        f"does not match required pattern: {pattern}"
                     )
                 return False
         elif mode == mlrun.common.schemas.RegexMatchModes.any:
@@ -203,7 +206,7 @@ def verify_field_regex(
     elif mode == mlrun.common.schemas.RegexMatchModes.any:
         if raise_on_failure:
             raise mlrun.errors.MLRunInvalidArgumentError(
-                f"Field '{field_name}' is malformed. '{field_value}' does not match any of the"
+                f"Field '{field_name[:max_chars]}' is malformed. '{field_value[:max_chars]}' does not match any of the"
                 f" required patterns: {patterns}"
             )
         return False

mlrun/utils/regex.py

@@ -21,9 +21,13 @@ pipeline_param = [r"{{pipelineparam:op=([\w\s_-]*);name=([\w\s_-]+)}}"]
 # k8s character limit is for 63 characters
 k8s_character_limit = [r"^.{0,63}$"]
 
+# k8s name
+# https://github.com/kubernetes/apimachinery/blob/kubernetes-1.25.16/pkg/util/validation/validation.go#L33
+qualified_name = [r"^(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])?$"]
+
 # k8s label value format
 # https://github.com/kubernetes/kubernetes/blob/v1.20.0/staging/src/k8s.io/apimachinery/pkg/util/validation/validation.go#L161
-label_value = k8s_character_limit + [r"^(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])?$"]
+label_value = k8s_character_limit + qualified_name
 
 # DNS Subdomain (RFC 1123) - used by k8s for most resource names format
 # https://github.com/kubernetes/kubernetes/blob/v1.20.0/staging/src/k8s.io/apimachinery/pkg/util/validation/validation.go#L204

mlrun/utils/version/version.json

@@ -1,4 +1,4 @@
 {
-  "git_commit": "da957867b45af23ee105545d29a1bb51c31b22a4",
-  "version": "1.7.0-rc1"
+  "git_commit": "523bdf379b1183bee50b5b0ebe61ddeae9d7ca1c",
+  "version": "1.7.0-rc2"
 }