zenml-nightly 0.73.0.dev20250204__py3-none-any.whl → 0.73.0.dev20250206__py3-none-any.whl

zenml/VERSION

@@ -1 +1 @@
-0.73.0.dev20250204
+0.73.0.dev20250206

zenml/cli/utils.py

@@ -18,6 +18,7 @@ import json
 import os
 import platform
 import re
+import shutil
 import subprocess
 import sys
 from typing import (
@@ -1048,22 +1049,18 @@ def install_packages(
         # just return without doing anything
         return
 
-    pip_command = ["uv", "pip"] if use_uv else ["pip"]
-    if upgrade:
-        command = (
-            [
-                sys.executable,
-                "-m",
-            ]
-            + pip_command
-            + [
-                "install",
-                "--upgrade",
-            ]
-            + packages
-        )
+    if use_uv and not is_installed_in_python_environment("uv"):
+        # If uv is installed globally, don't run as a python module
+        command = []
     else:
-        command = [sys.executable, "-m"] + pip_command + ["install"] + packages
+        command = [sys.executable, "-m"]
+
+    command += ["uv", "pip", "install"] if use_uv else ["pip", "install"]
+
+    if upgrade:
+        command += ["--upgrade"]
+
+    command += packages
 
     if not IS_DEBUG_ENV:
         quiet_flag = "-q" if use_uv else "-qqq"
@@ -1094,62 +1091,54 @@ def uninstall_package(package: str, use_uv: bool = False) -> None:
         package: The package to uninstall.
         use_uv: Whether to use uv for package uninstallation.
     """
-    pip_command = ["uv", "pip"] if use_uv else ["pip"]
-    quiet_flag = "-q" if use_uv else "-qqq"
-
-    if use_uv:
-        subprocess.check_call(
-            [
-                sys.executable,
-                "-m",
-            ]
-            + pip_command
-            + [
-                "uninstall",
-                quiet_flag,
-                package,
-            ]
-        )
+    if use_uv and not is_installed_in_python_environment("uv"):
+        # If uv is installed globally, don't run as a python module
+        command = []
     else:
-        subprocess.check_call(
-            [
-                sys.executable,
-                "-m",
-            ]
-            + pip_command
-            + [
-                "uninstall",
-                quiet_flag,
-                "-y",
-                package,
-            ]
-        )
+        command = [sys.executable, "-m"]
 
+    command += (
+        ["uv", "pip", "uninstall", "-q"]
+        if use_uv
+        else ["pip", "uninstall", "-y", "-qqq"]
+    )
+    command += [package]
 
-def is_uv_installed() -> bool:
-    """Check if uv is installed in the current environment.
+    subprocess.check_call(command)
+
+
+def is_installed_in_python_environment(package: str) -> bool:
+    """Check if a package is installed in the current python environment.
+
+    Args:
+        package: The package to check.
 
     Returns:
-        True if uv is installed, False otherwise.
+        True if the package is installed, False otherwise.
     """
     try:
-        pkg_resources.get_distribution("uv")
+        pkg_resources.get_distribution(package)
         return True
     except pkg_resources.DistributionNotFound:
         return False
 
 
+def is_uv_installed() -> bool:
+    """Check if uv is installed.
+
+    Returns:
+        True if uv is installed, False otherwise.
+    """
+    return shutil.which("uv") is not None
+
+
 def is_pip_installed() -> bool:
     """Check if pip is installed in the current environment.
 
     Returns:
         True if pip is installed, False otherwise.
     """
-    try:
-        pkg_resources.get_distribution("pip")
-        return True
-    except pkg_resources.DistributionNotFound:
-        return False
+    return is_installed_in_python_environment("pip")
 
 
 def pretty_print_secret(

zenml/client.py

@@ -3821,7 +3821,7 @@ class Client(metaclass=ClientMetaClass):
         templatable: Optional[bool] = None,
         tag: Optional[str] = None,
         user: Optional[Union[UUID, str]] = None,
-        run_metadata: Optional[Dict[str, str]] = None,
+        run_metadata: Optional[Dict[str, Any]] = None,
         pipeline: Optional[Union[UUID, str]] = None,
         code_repository: Optional[Union[UUID, str]] = None,
         model: Optional[Union[UUID, str]] = None,
@@ -3974,6 +3974,7 @@ class Client(metaclass=ClientMetaClass):
         user: Optional[Union[UUID, str]] = None,
         model_version_id: Optional[Union[str, UUID]] = None,
         model: Optional[Union[UUID, str]] = None,
+        run_metadata: Optional[Dict[str, Any]] = None,
         hydrate: bool = False,
     ) -> Page[StepRunResponse]:
         """List all pipelines.
@@ -4000,6 +4001,7 @@ class Client(metaclass=ClientMetaClass):
             cache_key: The cache key of the step run to filter by.
             code_hash: The code hash of the step run to filter by.
             status: The name of the run to filter by.
+            run_metadata: Filter by run metadata.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
@@ -4028,6 +4030,7 @@ class Client(metaclass=ClientMetaClass):
             user=user,
             model_version_id=model_version_id,
             model=model,
+            run_metadata=run_metadata,
         )
         step_run_filter_model.set_scope_workspace(self.active_workspace.id)
         return self.zen_store.list_run_steps(
@@ -4254,7 +4257,7 @@ class Client(metaclass=ClientMetaClass):
         user: Optional[Union[UUID, str]] = None,
         model: Optional[Union[UUID, str]] = None,
         pipeline_run: Optional[Union[UUID, str]] = None,
-        run_metadata: Optional[Dict[str, str]] = None,
+        run_metadata: Optional[Dict[str, Any]] = None,
         tag: Optional[str] = None,
         hydrate: bool = False,
     ) -> Page[ArtifactVersionResponse]:
@@ -4320,6 +4323,7 @@ class Client(metaclass=ClientMetaClass):
             user=user,
             model=model,
             pipeline_run=pipeline_run,
+            run_metadata=run_metadata,
         )
         artifact_version_filter_model.set_scope_workspace(
             self.active_workspace.id

zenml/constants.py

@@ -165,6 +165,7 @@ ENV_ZENML_DISABLE_CLIENT_SERVER_MISMATCH_WARNING = (
 )
 ENV_ZENML_DISABLE_WORKSPACE_WARNINGS = "ZENML_DISABLE_WORKSPACE_WARNINGS"
 ENV_ZENML_SKIP_IMAGE_BUILDER_DEFAULT = "ZENML_SKIP_IMAGE_BUILDER_DEFAULT"
+ENV_ZENML_SKIP_STACK_VALIDATION = "ZENML_SKIP_STACK_VALIDATION"
 ENV_ZENML_SERVER = "ZENML_SERVER"
 ENV_ZENML_ENFORCE_TYPE_ANNOTATIONS = "ZENML_ENFORCE_TYPE_ANNOTATIONS"
 ENV_ZENML_ENABLE_IMPLICIT_AUTH_METHODS = "ZENML_ENABLE_IMPLICIT_AUTH_METHODS"

zenml/integrations/gcp/image_builders/gcp_image_builder.py

@@ -18,7 +18,7 @@ from urllib.parse import urlparse
 
 from google.cloud.devtools import cloudbuild_v1
 
-from zenml.enums import ContainerRegistryFlavor, StackComponentType
+from zenml.enums import StackComponentType
 from zenml.image_builders import BaseImageBuilder
 from zenml.integrations.gcp import GCP_ARTIFACT_STORE_FLAVOR
 from zenml.integrations.gcp.flavors import GCPImageBuilderConfig
@@ -72,14 +72,11 @@ class GCPImageBuilder(BaseImageBuilder, GoogleCredentialsMixin):
         def _validate_remote_components(stack: "Stack") -> Tuple[bool, str]:
             assert stack.container_registry
 
-            if (
-                stack.container_registry.flavor
-                != ContainerRegistryFlavor.GCP.value
-            ):
+            if stack.container_registry.config.is_local:
                 return False, (
-                    "The GCP Image Builder requires a GCP container registry to "
-                    "push the image to. Please update your stack to include a "
-                    "GCP container registry and try again."
+                    "The GCP Image Builder requires a remote container "
+                    "registry to push the image to. Please update your stack "
+                    "to include a remote container registry and try again."
                 )
 
             if stack.artifact_store.flavor != GCP_ARTIFACT_STORE_FLAVOR:

zenml/models/__init__.py

@@ -28,6 +28,7 @@ from zenml.models.v2.base.base import (
     BaseDatedResponseBody,
 )
 from zenml.models.v2.base.scoped import (
+    TaggableFilter,
     UserScopedRequest,
     UserScopedFilter,
     UserScopedResponse,
@@ -39,7 +40,7 @@ from zenml.models.v2.base.scoped import (
     WorkspaceScopedResponseBody,
     WorkspaceScopedResponseMetadata,
     WorkspaceScopedResponseResources,
-    WorkspaceScopedTaggableFilter,
+    WorkspaceScopedFilter,
 )
 from zenml.models.v2.base.filter import (
     BaseFilter,
@@ -497,12 +498,13 @@ __all__ = [
     "WorkspaceScopedResponseBody",
     "WorkspaceScopedResponseMetadata",
     "WorkspaceScopedResponseResources",
-    "WorkspaceScopedTaggableFilter",
+    "WorkspaceScopedFilter",
     "BaseFilter",
     "StrFilter",
     "BoolFilter",
     "NumericFilter",
     "UUIDFilter",
+    "TaggableFilter",
     "Page",
     # V2 Core
     "ActionFilter",

zenml/models/v2/base/filter.py

@@ -171,6 +171,8 @@ class BoolFilter(Filter):
 class StrFilter(Filter):
     """Filter for all string fields."""
 
+    json_encode_value: bool = False
+
     ALLOWED_OPS: ClassVar[List[str]] = [
         GenericFilterOps.EQUALS,
         GenericFilterOps.NOT_EQUALS,
@@ -211,16 +213,6 @@ class StrFilter(Filter):
         Raises:
             ValueError: the comparison of the column to a numeric value fails.
         """
-        if self.operation == GenericFilterOps.CONTAINS:
-            return column.like(f"%{self.value}%")
-        if self.operation == GenericFilterOps.STARTSWITH:
-            return column.startswith(f"{self.value}")
-        if self.operation == GenericFilterOps.ENDSWITH:
-            return column.endswith(f"{self.value}")
-        if self.operation == GenericFilterOps.NOT_EQUALS:
-            return column != self.value
-        if self.operation == GenericFilterOps.ONEOF:
-            return column.in_(self.value)
         if self.operation in {
             GenericFilterOps.GT,
             GenericFilterOps.LT,
@@ -254,7 +246,33 @@ class StrFilter(Filter):
                     f"value '{self.value}' (must be numeric): {e}"
                 )
 
-        return column == self.value
+        if self.operation == GenericFilterOps.ONEOF:
+            assert isinstance(self.value, list)
+            # Convert the list of values to a list of json strings
+            json_list = (
+                [json.dumps(v) for v in self.value]
+                if self.json_encode_value
+                else self.value
+            )
+            return column.in_(json_list)
+
+        # Don't convert the value to a json string if the operation is contains
+        # because the quotes around strings will mess with the comparison
+        if self.operation == GenericFilterOps.CONTAINS:
+            return column.like(f"%{self.value}%")
+
+        json_value = (
+            json.dumps(self.value) if self.json_encode_value else self.value
+        )
+
+        if self.operation == GenericFilterOps.STARTSWITH:
+            return column.startswith(f"{json_value}")
+        if self.operation == GenericFilterOps.ENDSWITH:
+            return column.endswith(f"{json_value}")
+        if self.operation == GenericFilterOps.NOT_EQUALS:
+            return column != json_value
+
+        return column == json_value
 
 
 class UUIDFilter(StrFilter):
@@ -733,6 +751,7 @@ class BaseFilter(BaseModel):
         value: Any,
         table: Type[SQLModel],
         column: str,
+        json_encode_value: bool = False,
     ) -> "ColumnElement[bool]":
         """Generate custom filter conditions for a column of a table.
 
@@ -740,6 +759,7 @@ class BaseFilter(BaseModel):
             value: The filter value.
             table: The table which contains the column.
             column: The column name.
+            json_encode_value: Whether to json encode the value.
 
         Returns:
             The query conditions.
@@ -748,6 +768,9 @@ class BaseFilter(BaseModel):
         filter_ = FilterGenerator(table).define_filter(
             column=column, value=value, operator=operator
         )
+        if isinstance(filter_, StrFilter):
+            filter_.json_encode_value = json_encode_value
+
         return filter_.generate_query_conditions(table=table)
 
     @property

zenml/models/v2/base/scoped.py

@@ -464,19 +464,19 @@ class WorkspaceScopedFilter(UserScopedFilter):
         return super().apply_sorting(query=query, table=table)
 
 
-class WorkspaceScopedTaggableFilter(WorkspaceScopedFilter):
-    """Model to enable advanced scoping with workspace and tagging."""
+class TaggableFilter(BaseFilter):
+    """Model to enable filtering and sorting by tags."""
 
     tag: Optional[str] = Field(
         description="Tag to apply to the filter query.", default=None
     )
 
     FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
-        *WorkspaceScopedFilter.FILTER_EXCLUDE_FIELDS,
+        *BaseFilter.FILTER_EXCLUDE_FIELDS,
         "tag",
     ]
     CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = [
-        *WorkspaceScopedFilter.CUSTOM_SORTING_OPTIONS,
+        *BaseFilter.CUSTOM_SORTING_OPTIONS,
         "tags",
     ]
 

zenml/models/v2/core/artifact.py

@@ -35,7 +35,7 @@ from zenml.models.v2.base.base import (
     BaseResponseMetadata,
     BaseResponseResources,
 )
-from zenml.models.v2.base.scoped import WorkspaceScopedTaggableFilter
+from zenml.models.v2.base.scoped import TaggableFilter
 from zenml.models.v2.core.tag import TagResponse
 
 if TYPE_CHECKING:
@@ -183,14 +183,14 @@ class ArtifactResponse(
 # ------------------ Filter Model ------------------
 
 
-class ArtifactFilter(WorkspaceScopedTaggableFilter):
+class ArtifactFilter(TaggableFilter):
     """Model to enable advanced filtering of artifacts."""
 
     name: Optional[str] = None
     has_custom_name: Optional[bool] = None
 
     CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = [
-        *WorkspaceScopedTaggableFilter.CUSTOM_SORTING_OPTIONS,
+        *TaggableFilter.CUSTOM_SORTING_OPTIONS,
         SORT_BY_LATEST_VERSION_KEY,
     ]
 

zenml/models/v2/core/artifact_version.py

@@ -41,12 +41,13 @@ from zenml.logger import get_logger
 from zenml.metadata.metadata_types import MetadataType
 from zenml.models.v2.base.filter import FilterGenerator, StrFilter
 from zenml.models.v2.base.scoped import (
+    TaggableFilter,
+    WorkspaceScopedFilter,
     WorkspaceScopedRequest,
     WorkspaceScopedResponse,
     WorkspaceScopedResponseBody,
     WorkspaceScopedResponseMetadata,
     WorkspaceScopedResponseResources,
-    WorkspaceScopedTaggableFilter,
 )
 from zenml.models.v2.core.artifact import ArtifactResponse
 from zenml.models.v2.core.tag import TagResponse
@@ -469,11 +470,12 @@ class ArtifactVersionResponse(
 # ------------------ Filter Model ------------------
 
 
-class ArtifactVersionFilter(WorkspaceScopedTaggableFilter):
+class ArtifactVersionFilter(WorkspaceScopedFilter, TaggableFilter):
     """Model to enable advanced filtering of artifact versions."""
 
     FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
-        *WorkspaceScopedTaggableFilter.FILTER_EXCLUDE_FIELDS,
+        *WorkspaceScopedFilter.FILTER_EXCLUDE_FIELDS,
+        *TaggableFilter.FILTER_EXCLUDE_FIELDS,
         "name",
         "only_unused",
         "has_custom_name",
@@ -482,6 +484,15 @@ class ArtifactVersionFilter(WorkspaceScopedTaggableFilter):
         "model_version_id",
         "run_metadata",
     ]
+    CUSTOM_SORTING_OPTIONS = [
+        *WorkspaceScopedFilter.CUSTOM_SORTING_OPTIONS,
+        *TaggableFilter.CUSTOM_SORTING_OPTIONS,
+    ]
+    CLI_EXCLUDE_FIELDS = [
+        *WorkspaceScopedFilter.CLI_EXCLUDE_FIELDS,
+        *TaggableFilter.CLI_EXCLUDE_FIELDS,
+    ]
+
     artifact_id: Optional[Union[UUID, str]] = Field(
         default=None,
         description="ID of the artifact to which this version belongs.",
@@ -548,7 +559,7 @@ class ArtifactVersionFilter(WorkspaceScopedTaggableFilter):
         description="Name/ID of a pipeline run that is associated with this "
         "artifact version.",
     )
-    run_metadata: Optional[Dict[str, str]] = Field(
+    run_metadata: Optional[Dict[str, Any]] = Field(
         default=None,
         description="The run_metadata to filter the artifact versions by.",
     )
@@ -672,13 +683,19 @@ class ArtifactVersionFilter(WorkspaceScopedTaggableFilter):
                     RunMetadataResourceSchema.resource_id
                     == ArtifactVersionSchema.id,
                     RunMetadataResourceSchema.resource_type
-                    == MetadataResourceTypes.ARTIFACT_VERSION,
+                    == MetadataResourceTypes.ARTIFACT_VERSION.value,
                     RunMetadataResourceSchema.run_metadata_id
                     == RunMetadataSchema.id,
+                    self.generate_custom_query_conditions_for_column(
+                        value=key,
+                        table=RunMetadataSchema,
+                        column="key",
+                    ),
                     self.generate_custom_query_conditions_for_column(
                         value=value,
                         table=RunMetadataSchema,
                         column="value",
+                        json_encode_value=True,
                     ),
                 )
                 custom_filters.append(additional_filter)

zenml/models/v2/core/model.py

@@ -24,12 +24,13 @@ from zenml.constants import (
     TEXT_FIELD_MAX_LENGTH,
 )
 from zenml.models.v2.base.scoped import (
+    TaggableFilter,
+    WorkspaceScopedFilter,
     WorkspaceScopedRequest,
     WorkspaceScopedResponse,
     WorkspaceScopedResponseBody,
     WorkspaceScopedResponseMetadata,
     WorkspaceScopedResponseResources,
-    WorkspaceScopedTaggableFilter,
 )
 from zenml.utils.pagination_utils import depaginate
 
@@ -322,7 +323,7 @@ class ModelResponse(
 # ------------------ Filter Model ------------------
 
 
-class ModelFilter(WorkspaceScopedTaggableFilter):
+class ModelFilter(WorkspaceScopedFilter, TaggableFilter):
     """Model to enable advanced filtering of all Workspaces."""
 
     name: Optional[str] = Field(
@@ -330,10 +331,19 @@ class ModelFilter(WorkspaceScopedTaggableFilter):
         description="Name of the Model",
     )
 
+    FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
+        *WorkspaceScopedFilter.FILTER_EXCLUDE_FIELDS,
+        *TaggableFilter.FILTER_EXCLUDE_FIELDS,
+    ]
     CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = [
-        *WorkspaceScopedTaggableFilter.CUSTOM_SORTING_OPTIONS,
+        *WorkspaceScopedFilter.CUSTOM_SORTING_OPTIONS,
+        *TaggableFilter.CUSTOM_SORTING_OPTIONS,
         SORT_BY_LATEST_VERSION_KEY,
     ]
+    CLI_EXCLUDE_FIELDS = [
+        *WorkspaceScopedFilter.CLI_EXCLUDE_FIELDS,
+        *TaggableFilter.CLI_EXCLUDE_FIELDS,
+    ]
 
     def apply_sorting(
         self,

zenml/models/v2/core/model_version.py

@@ -33,12 +33,13 @@ from zenml.metadata.metadata_types import MetadataType
 from zenml.models.v2.base.filter import AnyQuery
 from zenml.models.v2.base.page import Page
 from zenml.models.v2.base.scoped import (
+    TaggableFilter,
+    WorkspaceScopedFilter,
     WorkspaceScopedRequest,
     WorkspaceScopedResponse,
     WorkspaceScopedResponseBody,
     WorkspaceScopedResponseMetadata,
     WorkspaceScopedResponseResources,
-    WorkspaceScopedTaggableFilter,
 )
 from zenml.models.v2.core.service import ServiceResponse
 from zenml.models.v2.core.tag import TagResponse
@@ -576,13 +577,22 @@ class ModelVersionResponse(
 # ------------------ Filter Model ------------------
 
 
-class ModelVersionFilter(WorkspaceScopedTaggableFilter):
+class ModelVersionFilter(WorkspaceScopedFilter, TaggableFilter):
     """Filter model for model versions."""
 
     FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
-        *WorkspaceScopedTaggableFilter.FILTER_EXCLUDE_FIELDS,
+        *WorkspaceScopedFilter.FILTER_EXCLUDE_FIELDS,
+        *TaggableFilter.FILTER_EXCLUDE_FIELDS,
         "run_metadata",
     ]
+    CUSTOM_SORTING_OPTIONS = [
+        *WorkspaceScopedFilter.CUSTOM_SORTING_OPTIONS,
+        *TaggableFilter.CUSTOM_SORTING_OPTIONS,
+    ]
+    CLI_EXCLUDE_FIELDS = [
+        *WorkspaceScopedFilter.CLI_EXCLUDE_FIELDS,
+        *TaggableFilter.CLI_EXCLUDE_FIELDS,
+    ]
 
     name: Optional[str] = Field(
         default=None,

zenml/models/v2/core/pipeline.py

@@ -34,12 +34,13 @@ from zenml.constants import (
 from zenml.enums import ExecutionStatus
 from zenml.models.v2.base.base import BaseUpdate
 from zenml.models.v2.base.scoped import (
+    TaggableFilter,
+    WorkspaceScopedFilter,
     WorkspaceScopedRequest,
     WorkspaceScopedResponse,
     WorkspaceScopedResponseBody,
     WorkspaceScopedResponseMetadata,
     WorkspaceScopedResponseResources,
-    WorkspaceScopedTaggableFilter,
 )
 from zenml.models.v2.core.tag import TagResponse
 
@@ -256,17 +257,23 @@ class PipelineResponse(
 # ------------------ Filter Model ------------------
 
 
-class PipelineFilter(WorkspaceScopedTaggableFilter):
+class PipelineFilter(WorkspaceScopedFilter, TaggableFilter):
     """Pipeline filter model."""
 
     CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = [
-        *WorkspaceScopedTaggableFilter.CUSTOM_SORTING_OPTIONS,
+        *WorkspaceScopedFilter.CUSTOM_SORTING_OPTIONS,
+        *TaggableFilter.CUSTOM_SORTING_OPTIONS,
         SORT_PIPELINES_BY_LATEST_RUN_KEY,
     ]
     FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
-        *WorkspaceScopedTaggableFilter.FILTER_EXCLUDE_FIELDS,
+        *WorkspaceScopedFilter.FILTER_EXCLUDE_FIELDS,
+        *TaggableFilter.FILTER_EXCLUDE_FIELDS,
         "latest_run_status",
     ]
+    CLI_EXCLUDE_FIELDS = [
+        *WorkspaceScopedFilter.CLI_EXCLUDE_FIELDS,
+        *TaggableFilter.CLI_EXCLUDE_FIELDS,
+    ]
 
     name: Optional[str] = Field(
         default=None,

zenml/models/v2/core/pipeline_run.py

@@ -35,12 +35,13 @@ from zenml.constants import STR_FIELD_MAX_LENGTH
 from zenml.enums import ExecutionStatus
 from zenml.metadata.metadata_types import MetadataType
 from zenml.models.v2.base.scoped import (
+    TaggableFilter,
+    WorkspaceScopedFilter,
     WorkspaceScopedRequest,
     WorkspaceScopedResponse,
     WorkspaceScopedResponseBody,
     WorkspaceScopedResponseMetadata,
     WorkspaceScopedResponseResources,
-    WorkspaceScopedTaggableFilter,
 )
 from zenml.models.v2.core.model_version import ModelVersionResponse
 from zenml.models.v2.core.tag import TagResponse
@@ -589,20 +590,21 @@ class PipelineRunResponse(
 # ------------------ Filter Model ------------------
 
 
-class PipelineRunFilter(WorkspaceScopedTaggableFilter):
+class PipelineRunFilter(WorkspaceScopedFilter, TaggableFilter):
     """Model to enable advanced filtering of all Workspaces."""
 
     CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = [
-        *WorkspaceScopedTaggableFilter.CUSTOM_SORTING_OPTIONS,
+        *WorkspaceScopedFilter.CUSTOM_SORTING_OPTIONS,
+        *TaggableFilter.CUSTOM_SORTING_OPTIONS,
         "tag",
         "stack",
         "pipeline",
         "model",
         "model_version",
     ]
-
     FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
-        *WorkspaceScopedTaggableFilter.FILTER_EXCLUDE_FIELDS,
+        *WorkspaceScopedFilter.FILTER_EXCLUDE_FIELDS,
+        *TaggableFilter.FILTER_EXCLUDE_FIELDS,
         "unlisted",
         "code_repository_id",
         "build_id",
@@ -618,6 +620,11 @@ class PipelineRunFilter(WorkspaceScopedTaggableFilter):
         "templatable",
         "run_metadata",
     ]
+    CLI_EXCLUDE_FIELDS = [
+        *WorkspaceScopedFilter.CLI_EXCLUDE_FIELDS,
+        *TaggableFilter.CLI_EXCLUDE_FIELDS,
+    ]
+
     name: Optional[str] = Field(
         default=None,
         description="Name of the Pipeline Run",
@@ -681,7 +688,7 @@ class PipelineRunFilter(WorkspaceScopedTaggableFilter):
         union_mode="left_to_right",
     )
     unlisted: Optional[bool] = None
-    run_metadata: Optional[Dict[str, str]] = Field(
+    run_metadata: Optional[Dict[str, Any]] = Field(
         default=None,
         description="The run_metadata to filter the pipeline runs by.",
     )
@@ -908,13 +915,19 @@ class PipelineRunFilter(WorkspaceScopedTaggableFilter):
                     RunMetadataResourceSchema.resource_id
                     == PipelineRunSchema.id,
                     RunMetadataResourceSchema.resource_type
-                    == MetadataResourceTypes.PIPELINE_RUN,
+                    == MetadataResourceTypes.PIPELINE_RUN.value,
                     RunMetadataResourceSchema.run_metadata_id
                     == RunMetadataSchema.id,
+                    self.generate_custom_query_conditions_for_column(
+                        value=key,
+                        table=RunMetadataSchema,
+                        column="key",
+                    ),
                     self.generate_custom_query_conditions_for_column(
                         value=value,
                         table=RunMetadataSchema,
                         column="value",
+                        json_encode_value=True,
                     ),
                 )
                 custom_filters.append(additional_filter)