mlrun 1.7.0rc43__py3-none-any.whl → 1.7.0rc55__py3-none-any.whl

mlrun/__main__.py

@@ -734,9 +734,11 @@ def get(kind, name, selector, namespace, uid, project, tag, db, extra_args):
     if db:
         mlconf.dbpath = db
     if not project:
-        print("Warning, project parameter was not specified using default !")
+        logger.warning(
+            "Project parameter was not specified. Defaulting to 'default' project"
+        )
     if kind.startswith("po"):
-        print("Unsupported, use 'get runtimes' instead")
+        logger.warning("Unsupported, use 'get runtimes' instead")
         return
 
     elif kind.startswith("runtime"):

mlrun/artifacts/manager.py

@@ -200,7 +200,9 @@ class ArtifactManager:
         :param artifact_path: The path to store the artifact.
          If not provided, the artifact will be stored in the default artifact path.
         :param format: The format of the artifact. (e.g. csv, json, html, etc.)
-        :param upload: Whether to upload the artifact or not.
+        :param upload: Whether to upload the artifact to the datastore. If not provided, and the
+        `local_path` is not a directory, upload occurs by default. Directories are uploaded only when this
+        flag is explicitly set to `True`.
         :param labels: Labels to add to the artifact.
         :param db_key: The key to use when logging the artifact to the DB.
         If not provided, will generate a key based on the producer name and the artifact key.

mlrun/common/formatters/__init__.py

@@ -18,3 +18,4 @@ from .function import FunctionFormat  # noqa
 from .pipeline import PipelineFormat  # noqa
 from .project import ProjectFormat  # noqa
 from .run import RunFormat  # noqa
+from .feature_set import FeatureSetFormat  # noqa

mlrun/{model_monitoring/application.py → common/formatters/feature_set.py}

@@ -1,4 +1,4 @@
-# Copyright 2023 Iguazio
+# Copyright 2024 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,9 +11,23 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+#
+
+import typing
+
+import mlrun.common.types
+
+from .base import ObjectFormat
+
+
+class FeatureSetFormat(ObjectFormat, mlrun.common.types.StrEnum):
+    minimal = "minimal"
 
-# TODO : delete this file in 1.9.0
-from mlrun.model_monitoring.applications import (  # noqa: F401
-    ModelMonitoringApplicationBase,
-    ModelMonitoringApplicationResult,
-)
+    @staticmethod
+    def format_method(_format: str) -> typing.Optional[typing.Callable]:
+        return {
+            FeatureSetFormat.full: None,
+            FeatureSetFormat.minimal: FeatureSetFormat.filter_obj_method(
+                ["kind", "metadata", "spec", "status.state"]
+            ),
+        }[_format]

mlrun/common/formatters/run.py

@@ -22,5 +22,8 @@ class RunFormat(ObjectFormat, mlrun.common.types.StrEnum):
     # No enrichment, data is pulled as-is from the database.
     standard = "standard"
 
+    # Enrich run with full notifications since the notification params are subtracted from the run body.
+    notifications = "notifications"
+
     # Performs run enrichment, including the run's artifacts. Only available for the `get` run API.
     full = "full"

mlrun/common/schemas/__init__.py

@@ -175,6 +175,7 @@ from .project import (
     ProjectOwner,
     ProjectsOutput,
     ProjectSpec,
+    ProjectSpecOut,
     ProjectState,
     ProjectStatus,
     ProjectSummariesOutput,

mlrun/common/schemas/alert.py

@@ -34,17 +34,17 @@ class EventEntities(pydantic.BaseModel):
 
 
 class EventKind(StrEnum):
-    DATA_DRIFT_DETECTED = "data_drift_detected"
-    DATA_DRIFT_SUSPECTED = "data_drift_suspected"
-    CONCEPT_DRIFT_DETECTED = "concept_drift_detected"
-    CONCEPT_DRIFT_SUSPECTED = "concept_drift_suspected"
-    MODEL_PERFORMANCE_DETECTED = "model_performance_detected"
-    MODEL_PERFORMANCE_SUSPECTED = "model_performance_suspected"
-    SYSTEM_PERFORMANCE_DETECTED = "system_performance_detected"
-    SYSTEM_PERFORMANCE_SUSPECTED = "system_performance_suspected"
-    MM_APP_ANOMALY_DETECTED = "mm_app_anomaly_detected"
-    MM_APP_ANOMALY_SUSPECTED = "mm_app_anomaly_suspected"
-    MM_APP_FAILED = "mm_app_failed"
+    DATA_DRIFT_DETECTED = "data-drift-detected"
+    DATA_DRIFT_SUSPECTED = "data-drift-suspected"
+    CONCEPT_DRIFT_DETECTED = "concept-drift-detected"
+    CONCEPT_DRIFT_SUSPECTED = "concept-drift-suspected"
+    MODEL_PERFORMANCE_DETECTED = "model-performance-detected"
+    MODEL_PERFORMANCE_SUSPECTED = "model-performance-suspected"
+    SYSTEM_PERFORMANCE_DETECTED = "system-performance-detected"
+    SYSTEM_PERFORMANCE_SUSPECTED = "system-performance-suspected"
+    MM_APP_ANOMALY_DETECTED = "mm-app-anomaly-detected"
+    MM_APP_ANOMALY_SUSPECTED = "mm-app-anomaly-suspected"
+    MM_APP_FAILED = "mm-app-failed"
     FAILED = "failed"
 
 

mlrun/common/schemas/auth.py

@@ -63,6 +63,7 @@ class AuthorizationResourceTypes(mlrun.common.types.StrEnum):
     event = "event"
     datastore_profile = "datastore-profile"
     api_gateway = "api-gateway"
+    project_summaries = "project-summaries"
 
     def to_resource_string(
         self,
@@ -72,6 +73,7 @@ class AuthorizationResourceTypes(mlrun.common.types.StrEnum):
         return {
             # project is the resource itself, so no need for both resource_name and project_name
             AuthorizationResourceTypes.project: "/projects/{project_name}",
+            AuthorizationResourceTypes.project_summaries: "/projects/{project_name}/project-summaries/{resource_name}",
             AuthorizationResourceTypes.function: "/projects/{project_name}/functions/{resource_name}",
             AuthorizationResourceTypes.artifact: "/projects/{project_name}/artifacts/{resource_name}",
             AuthorizationResourceTypes.project_background_task: (
@@ -139,6 +141,9 @@ class AuthInfo(pydantic.BaseModel):
             member_ids.extend(self.user_group_ids)
         return member_ids
 
+    def get_session(self) -> str:
+        return self.data_session or self.session
+
 
 class Credentials(pydantic.BaseModel):
     access_key: typing.Optional[str]

mlrun/common/schemas/client_spec.py

@@ -57,7 +57,6 @@ class ClientSpec(pydantic.BaseModel):
     redis_url: typing.Optional[str]
     redis_type: typing.Optional[str]
     sql_url: typing.Optional[str]
-    model_endpoint_monitoring_store_type: typing.Optional[str]
     model_endpoint_monitoring_endpoint_store_connection: typing.Optional[str]
     model_monitoring_tsdb_connection: typing.Optional[str]
     ce: typing.Optional[dict]

mlrun/common/schemas/model_monitoring/__init__.py

@@ -25,6 +25,7 @@ from .constants import (
     FileTargetKind,
     FunctionURI,
     MetricData,
+    ModelEndpointMonitoringMetricType,
     ModelEndpointTarget,
     ModelEndpointTargetSchemas,
     ModelMonitoringMode,
@@ -34,6 +35,7 @@ from .constants import (
     ProjectSecretKeys,
     ResultData,
     ResultKindApp,
+    ResultStatusApp,
     SchedulingKeys,
     SpecialApps,
     TDEngineSuperTables,
@@ -60,7 +62,6 @@ from .model_endpoints import (
     ModelEndpointMetadata,
     ModelEndpointMonitoringMetric,
     ModelEndpointMonitoringMetricNoData,
-    ModelEndpointMonitoringMetricType,
     ModelEndpointMonitoringMetricValues,
     ModelEndpointMonitoringResultValues,
     ModelEndpointSpec,

mlrun/common/schemas/model_monitoring/constants.py

@@ -13,7 +13,8 @@
 # limitations under the License.
 
 import hashlib
-from dataclasses import dataclass
+import re
+from dataclasses import dataclass, field
 from enum import Enum, IntEnum
 from typing import Optional
 
@@ -104,15 +105,8 @@ class ApplicationEvent:
     APPLICATION_NAME = "application_name"
     START_INFER_TIME = "start_infer_time"
     END_INFER_TIME = "end_infer_time"
-    LAST_REQUEST = "last_request"
     ENDPOINT_ID = "endpoint_id"
     OUTPUT_STREAM_URI = "output_stream_uri"
-    MLRUN_CONTEXT = "mlrun_context"
-
-    # Deprecated fields - TODO : delete in 1.9.0  (V1 app deprecation)
-    SAMPLE_PARQUET_PATH = "sample_parquet_path"
-    CURRENT_STATS = "current_stats"
-    FEATURE_STATS = "feature_stats"
 
 
 class WriterEvent(MonitoringStrEnum):
@@ -295,7 +289,7 @@ class EndpointUID:
     function_hash_key: str
     model: str
     model_version: str
-    uid: Optional[str] = None
+    uid: str = field(init=False)
 
     def __post_init__(self):
         function_ref = (
@@ -372,3 +366,23 @@ _RESERVED_FUNCTION_NAMES = MonitoringFunctionNames.list() + [SpecialApps.MLRUN_I
 
 
 V3IO_MODEL_MONITORING_DB = "v3io"
+
+
+class ModelEndpointMonitoringMetricType(StrEnum):
+    RESULT = "result"
+    METRIC = "metric"
+
+
+_FQN_PART_PATTERN = r"[a-zA-Z0-9_-]+"
+FQN_PATTERN = (
+    rf"^(?P<project>{_FQN_PART_PATTERN})\."
+    rf"(?P<app>{_FQN_PART_PATTERN})\."
+    rf"(?P<type>{ModelEndpointMonitoringMetricType.RESULT}|{ModelEndpointMonitoringMetricType.METRIC})\."
+    rf"(?P<name>{_FQN_PART_PATTERN})$"
+)
+FQN_REGEX = re.compile(FQN_PATTERN)
+
+# refer to `mlrun.utils.regex.project_name`
+PROJECT_PATTERN = r"^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$"
+
+MODEL_ENDPOINT_ID_PATTERN = r"^[a-zA-Z0-9_-]+$"

mlrun/common/schemas/model_monitoring/model_endpoints.py

@@ -14,26 +14,32 @@
 
 import enum
 import json
-import re
 from datetime import datetime
-from typing import Any, NamedTuple, Optional
+from typing import Any, NamedTuple, Optional, TypeVar
 
-from pydantic import BaseModel, Field, validator
-from pydantic.main import Extra
+from pydantic import BaseModel, Extra, Field, constr, validator
 
-import mlrun.common.types
+# TODO: remove the unused import below after `mlrun.datastore` and `mlrun.utils` usage is removed.
+# At the moment `make lint` fails if this is removed.
+import mlrun.common.model_monitoring
 
 from ..object import ObjectKind, ObjectSpec, ObjectStatus
 from .constants import (
+    FQN_REGEX,
+    MODEL_ENDPOINT_ID_PATTERN,
+    PROJECT_PATTERN,
     EndpointType,
     EventFieldType,
     EventKeyMetrics,
     EventLiveStats,
+    ModelEndpointMonitoringMetricType,
     ModelMonitoringMode,
     ResultKindApp,
     ResultStatusApp,
 )
 
+Model = TypeVar("Model", bound=BaseModel)
+
 
 class ModelMonitoringStoreKinds:
     # TODO: do changes in examples & demos In 1.5.0 remove
@@ -42,9 +48,9 @@ class ModelMonitoringStoreKinds:
 
 
 class ModelEndpointMetadata(BaseModel):
-    project: Optional[str] = ""
+    project: constr(regex=PROJECT_PATTERN)
+    uid: constr(regex=MODEL_ENDPOINT_ID_PATTERN)
     labels: Optional[dict] = {}
-    uid: Optional[str] = ""
 
     class Config:
         extra = Extra.allow
@@ -57,12 +63,11 @@ class ModelEndpointMetadata(BaseModel):
         :param json_parse_values: List of dictionary keys with a JSON string value that will be parsed into a
                                   dictionary using json.loads().
         """
-        new_object = cls()
         if json_parse_values is None:
             json_parse_values = [EventFieldType.LABELS]
 
         return _mapping_attributes(
-            base_model=new_object,
+            model_class=cls,
             flattened_dictionary=endpoint_dict,
             json_parse_values=json_parse_values,
         )
@@ -89,7 +94,6 @@ class ModelEndpointSpec(ObjectSpec):
         :param json_parse_values: List of dictionary keys with a JSON string value that will be parsed into a
                                   dictionary using json.loads().
         """
-        new_object = cls()
         if json_parse_values is None:
             json_parse_values = [
                 EventFieldType.FEATURE_NAMES,
@@ -97,7 +101,7 @@ class ModelEndpointSpec(ObjectSpec):
                 EventFieldType.MONITOR_CONFIGURATION,
             ]
         return _mapping_attributes(
-            base_model=new_object,
+            model_class=cls,
             flattened_dictionary=endpoint_dict,
             json_parse_values=json_parse_values,
         )
@@ -191,7 +195,6 @@ class ModelEndpointStatus(ObjectStatus):
         :param json_parse_values: List of dictionary keys with a JSON string value that will be parsed into a
                                   dictionary using json.loads().
         """
-        new_object = cls()
         if json_parse_values is None:
             json_parse_values = [
                 EventFieldType.FEATURE_STATS,
@@ -203,7 +206,7 @@ class ModelEndpointStatus(ObjectStatus):
                 EventFieldType.ENDPOINT_TYPE,
             ]
         return _mapping_attributes(
-            base_model=new_object,
+            model_class=cls,
             flattened_dictionary=endpoint_dict,
             json_parse_values=json_parse_values,
         )
@@ -211,22 +214,13 @@ class ModelEndpointStatus(ObjectStatus):
 
 class ModelEndpoint(BaseModel):
     kind: ObjectKind = Field(ObjectKind.model_endpoint, const=True)
-    metadata: ModelEndpointMetadata = ModelEndpointMetadata()
+    metadata: ModelEndpointMetadata
     spec: ModelEndpointSpec = ModelEndpointSpec()
     status: ModelEndpointStatus = ModelEndpointStatus()
 
     class Config:
         extra = Extra.allow
 
-    def __init__(self, **data: Any):
-        super().__init__(**data)
-        if self.metadata.uid is None:
-            uid = mlrun.common.model_monitoring.create_model_endpoint_uid(
-                function_uri=self.spec.function_uri,
-                versioned_model=self.spec.model,
-            )
-            self.metadata.uid = str(uid)
-
     def flat_dict(self):
         """Generate a flattened `ModelEndpoint` dictionary. The flattened dictionary result is important for storing
         the model endpoint object in the database.
@@ -267,7 +261,7 @@ class ModelEndpoint(BaseModel):
         return flatten_dict
 
     @classmethod
-    def from_flat_dict(cls, endpoint_dict: dict):
+    def from_flat_dict(cls, endpoint_dict: dict) -> "ModelEndpoint":
         """Create a `ModelEndpoint` object from an endpoint flattened dictionary. Because the provided dictionary
         is flattened, we pass it as is to the subclasses without splitting the keys into spec, metadata, and status.
 
@@ -285,11 +279,6 @@ class ModelEndpointList(BaseModel):
     endpoints: list[ModelEndpoint] = []
 
 
-class ModelEndpointMonitoringMetricType(mlrun.common.types.StrEnum):
-    RESULT = "result"
-    METRIC = "metric"
-
-
 class ModelEndpointMonitoringMetric(BaseModel):
     project: str
     app: str
@@ -308,18 +297,8 @@ def _compose_full_name(
     return ".".join([project, app, type, name])
 
 
-_FQN_PART_PATTERN = r"[a-zA-Z0-9_-]+"
-_FQN_PATTERN = (
-    rf"^(?P<project>{_FQN_PART_PATTERN})\."
-    rf"(?P<app>{_FQN_PART_PATTERN})\."
-    rf"(?P<type>{ModelEndpointMonitoringMetricType.RESULT}|{ModelEndpointMonitoringMetricType.METRIC})\."
-    rf"(?P<name>{_FQN_PART_PATTERN})$"
-)
-_FQN_REGEX = re.compile(_FQN_PATTERN)
-
-
 def _parse_metric_fqn_to_monitoring_metric(fqn: str) -> ModelEndpointMonitoringMetric:
-    match = _FQN_REGEX.fullmatch(fqn)
+    match = FQN_REGEX.fullmatch(fqn)
     if match is None:
         raise ValueError("The fully qualified name is not in the expected format")
     return ModelEndpointMonitoringMetric.parse_obj(
@@ -364,20 +343,18 @@ class ModelEndpointMonitoringMetricNoData(_ModelEndpointMonitoringMetricValuesBa
 
 
 def _mapping_attributes(
-    base_model: BaseModel,
-    flattened_dictionary: dict,
-    json_parse_values: list = None,
-):
+    model_class: type[Model], flattened_dictionary: dict, json_parse_values: list
+) -> Model:
     """Generate a `BaseModel` object with the provided dictionary attributes.
 
-    :param base_model:           `BaseModel` object (e.g. `ModelEndpointMetadata`).
+    :param model_class:          `BaseModel` class (e.g. `ModelEndpointMetadata`).
     :param flattened_dictionary: Flattened dictionary that contains the model endpoint attributes.
     :param json_parse_values:    List of dictionary keys with a JSON string value that will be parsed into a
                                  dictionary using json.loads().
     """
     # Get the fields of the provided base model object. These fields will be used to filter to relevent keys
     # from the flattened dictionary.
-    wanted_keys = base_model.__fields__.keys()
+    wanted_keys = model_class.__fields__.keys()
 
     # Generate a filtered flattened dictionary that will be parsed into the BaseModel object
     dict_to_parse = {}
@@ -391,7 +368,7 @@ def _mapping_attributes(
             else:
                 dict_to_parse[field_key] = flattened_dictionary[field_key]
 
-    return base_model.parse_obj(dict_to_parse)
+    return model_class.parse_obj(dict_to_parse)
 
 
 def _json_loads_if_not_none(field: Any) -> Any:

mlrun/common/schemas/notification.py

@@ -50,9 +50,19 @@ class NotificationKind(mlrun.common.types.StrEnum):
     **url** - The webhook url to which to send the notification.\n
     **method** - The http method to use when sending the notification (GET, POST, PUT, etc…).\n
     **headers** - (dict) The http headers to send with the notification.\n
-    **override_body** - (dict) The body to send with the notification.\n
+    **override_body** -
+     (dict) The body to send with the notification. If not specified, the
+     default body will be a dictionary containing `name`, `message`, `severity`, and a `runs` list of the
+     completed runs. You can also add the run's details.\n
+     Example::
+
+                "override_body": {"message":"Run Completed {{ runs }}"
+                # Results would look like:
+                "message": "Run Completed [{'project': 'my-project', 'name': 'my-function', 'host': <run-host>,
+                         'status': {'state': 'completed', 'results': <run-results>}}]"
     **verify_ssl** -
-     (bool) Whether SSL certificates are validated during HTTP requests or not, The default is set to True.
+     (bool) Whether SSL certificates are validated during HTTP requests or not.
+     The default is set to True.\n
     """
 
 

mlrun/common/schemas/workflow.py

@@ -16,8 +16,9 @@ import typing
 
 import pydantic
 
-from .notification import Notification
-from .schedule import ScheduleCronTrigger
+from mlrun.common.schemas.notification import Notification
+from mlrun.common.schemas.schedule import ScheduleCronTrigger
+from mlrun.common.types import StrEnum
 
 
 class WorkflowSpec(pydantic.BaseModel):
@@ -32,6 +33,7 @@ class WorkflowSpec(pydantic.BaseModel):
     schedule: typing.Union[str, ScheduleCronTrigger] = None
     run_local: typing.Optional[bool] = None
     image: typing.Optional[str] = None
+    workflow_runner_node_selector: typing.Optional[dict[str, str]] = None
 
 
 class WorkflowRequest(pydantic.BaseModel):
@@ -54,3 +56,9 @@ class WorkflowResponse(pydantic.BaseModel):
 
 class GetWorkflowResponse(pydantic.BaseModel):
     workflow_id: str = None
+
+
+class EngineType(StrEnum):
+    LOCAL = "local"
+    REMOTE = "remote"
+    KFP = "kfp"

mlrun/config.py

@@ -539,7 +539,6 @@ default_config = {
         "store_prefixes": {
             "default": "v3io:///users/pipelines/{project}/model-endpoints/{kind}",
             "user_space": "v3io:///projects/{project}/model-endpoints/{kind}",
-            "stream": "",  # TODO: Delete in 1.9.0
             "monitoring_application": "v3io:///users/pipelines/{project}/monitoring-apps/",
         },
         # Offline storage path can be either relative or a full path. This path is used for general offline data
@@ -552,7 +551,6 @@ default_config = {
         "parquet_batching_max_events": 10_000,
         "parquet_batching_timeout_secs": timedelta(minutes=1).total_seconds(),
         # See mlrun.model_monitoring.db.stores.ObjectStoreFactory for available options
-        "store_type": "v3io-nosql",  # TODO: Delete in 1.9.0
         "endpoint_store_connection": "",
         # See mlrun.model_monitoring.db.tsdb.ObjectTSDBFactory for available options
         "tsdb_connection": "",
@@ -736,7 +734,7 @@ default_config = {
     "grafana_url": "",
     "alerts": {
         # supported modes: "enabled", "disabled".
-        "mode": "enabled",
+        "mode": "disabled",
         # maximum number of alerts we allow to be configured.
         # user will get an error when exceeding this
         "max_allowed": 10000,
@@ -798,7 +796,21 @@ class Config:
         for key, value in cfg.items():
             if hasattr(self, key):
                 if isinstance(value, dict):
-                    getattr(self, key).update(value)
+                    # ignore the `skip_errors` flag here
+                    # if the key does not align with what mlrun config expects it is a user
+                    # input error that can lead to unexpected behavior.
+                    # raise the exception to ensure configuration is loaded correctly and do not
+                    # ignore any errors.
+                    config_value = getattr(self, key)
+                    try:
+                        config_value.update(value)
+                    except AttributeError as exc:
+                        if not isinstance(config_value, (dict, Config)):
+                            raise ValueError(
+                                f"Can not update `{key}` config. "
+                                f"Expected a configuration but received {type(value)}"
+                            ) from exc
+                        raise exc
                 else:
                     try:
                         setattr(self, key, value)
@@ -1102,6 +1114,9 @@ class Config:
             # importing here to avoid circular dependency
             import mlrun.db
 
+            # It ensures that SSL verification is set before establishing a connection
+            _configure_ssl_verification(self.httpdb.http.verify)
+
             # when dbpath is set we want to connect to it which will sync configuration from it to the client
             mlrun.db.get_run_db(value, force_reconnect=True)
 
@@ -1130,10 +1145,10 @@ class Config:
         project: str = "",
         kind: str = "",
         target: str = "online",
-        artifact_path: str = None,
-        function_name: str = None,
+        artifact_path: typing.Optional[str] = None,
+        function_name: typing.Optional[str] = None,
         **kwargs,
-    ) -> typing.Union[str, list[str]]:
+    ) -> str:
         """Get the full path from the configuration based on the provided project and kind.
 
         :param project:         Project name.
@@ -1149,8 +1164,7 @@ class Config:
                                 relative artifact path will be taken from the global MLRun artifact path.
         :param function_name:    Application name, None for model_monitoring_stream.
 
-        :return:                Full configured path for the provided kind. Can be either a single path
-                                or a list of paths in the case of the online model monitoring stream path.
+        :return:                Full configured path for the provided kind.
         """
 
         if target != "offline":
@@ -1171,18 +1185,11 @@ class Config:
                     if function_name is None
                     else f"{kind}-{function_name.lower()}",
                 )
-            elif kind == "stream":  # return list for mlrun<1.6.3 BC
-                return [
-                    # TODO: remove the first stream in 1.9.0
-                    mlrun.mlconf.model_endpoint_monitoring.store_prefixes.default.format(
-                        project=project,
-                        kind=kind,
-                    ),  # old stream uri (pipelines) for BC ML-6043
-                    mlrun.mlconf.model_endpoint_monitoring.store_prefixes.user_space.format(
-                        project=project,
-                        kind=kind,
-                    ),  # new stream uri (projects)
-                ]
+            elif kind == "stream":
+                return mlrun.mlconf.model_endpoint_monitoring.store_prefixes.user_space.format(
+                    project=project,
+                    kind=kind,
+                )
             else:
                 return mlrun.mlconf.model_endpoint_monitoring.store_prefixes.default.format(
                     project=project,

mlrun/data_types/data_types.py

@@ -70,6 +70,11 @@ def pa_type_to_value_type(type_):
     if isinstance(type_, TimestampType):
         return ValueType.DATETIME
 
+    # pandas category type translates to pyarrow DictionaryType
+    # we need to unpack the value type (ML-7868)
+    if isinstance(type_, pyarrow.DictionaryType):
+        type_ = type_.value_type
+
     type_map = {
         pyarrow.bool_(): ValueType.BOOL,
         pyarrow.int64(): ValueType.INT64,
@@ -139,7 +144,7 @@ def gbq_to_pandas_dtype(gbq_type):
         "BOOL": "bool",
         "FLOAT": "float64",
         "INTEGER": pd.Int64Dtype(),
-        "TIMESTAMP": "datetime64[ns]",
+        "TIMESTAMP": "datetime64[ns, UTC]",
     }
     return type_map.get(gbq_type, "object")
 

mlrun/datastore/base.py

@@ -29,7 +29,7 @@ from deprecated import deprecated
 import mlrun.config
 import mlrun.errors
 from mlrun.errors import err_to_str
-from mlrun.utils import StorePrefix, is_ipython, logger
+from mlrun.utils import StorePrefix, is_jupyter, logger
 
 from .store_resources import is_store_uri, parse_store_uri
 from .utils import filter_df_start_end_time, select_columns_from_df
@@ -619,14 +619,14 @@ class DataItem:
         )
         return df
 
-    def show(self, format=None):
+    def show(self, format: Optional[str] = None) -> None:
         """show the data object content in Jupyter
 
         :param format: format to use (when there is no/wrong suffix), e.g. 'png'
         """
-        if not is_ipython:
+        if not is_jupyter:
             logger.warning(
-                "Jupyter/IPython was not detected, .show() will only display inside Jupyter"
+                "Jupyter was not detected. `.show()` displays only inside Jupyter."
             )
             return