zenml-nightly 0.75.0.dev20250318__py3-none-any.whl → 0.80.0.dev20250321__py3-none-any.whl

zenml/models/v2/base/scoped.py

@@ -426,6 +426,10 @@ class TaggableFilter(BaseFilter):
         *BaseFilter.CUSTOM_SORTING_OPTIONS,
         "tags",
     ]
+    API_MULTI_INPUT_PARAMS: ClassVar[List[str]] = [
+        *BaseFilter.API_MULTI_INPUT_PARAMS,
+        "tags",
+    ]
 
     @model_validator(mode="after")
     def add_tag_to_tags(self) -> "TaggableFilter":
@@ -583,3 +587,131 @@ class TaggableFilter(BaseFilter):
             return query
 
         return super().apply_sorting(query=query, table=table)
+
+
+class RunMetadataFilterMixin(BaseFilter):
+    """Model to enable filtering and sorting by run metadata."""
+
+    run_metadata: Optional[List[str]] = Field(
+        default=None,
+        description="The run_metadata to filter the pipeline runs by.",
+    )
+    FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
+        *BaseFilter.FILTER_EXCLUDE_FIELDS,
+        "run_metadata",
+    ]
+    API_MULTI_INPUT_PARAMS: ClassVar[List[str]] = [
+        *BaseFilter.API_MULTI_INPUT_PARAMS,
+        "run_metadata",
+    ]
+
+    @model_validator(mode="after")
+    def validate_run_metadata_format(self) -> "RunMetadataFilterMixin":
+        """Validates that run_metadata entries are in the correct format.
+
+        Each run_metadata entry must be in one of the following formats:
+        1. "key:value" - Direct equality comparison (key equals value)
+        2. "key:filterop:value" - Where filterop is one of the GenericFilterOps:
+           - equals: Exact match
+           - notequals: Not equal to
+           - contains: String contains value
+           - startswith: String starts with value
+           - endswith: String ends with value
+           - oneof: Value is one of the specified options
+           - gte: Greater than or equal to
+           - gt: Greater than
+           - lte: Less than or equal to
+           - lt: Less than
+           - in: Value is in a list
+
+        Examples:
+        - "status:completed" - Find entries where status equals "completed"
+        - "name:contains:test" - Find entries where name contains "test"
+        - "duration:gt:10" - Find entries where duration is greater than 10
+
+        Returns:
+            self
+
+        Raises:
+            ValueError: If any entry in run_metadata does not contain a colon.
+        """
+        if self.run_metadata:
+            for entry in self.run_metadata:
+                if ":" not in entry:
+                    raise ValueError(
+                        f"Invalid run_metadata entry format: '{entry}'. "
+                        "Entry must be in format 'key:value' for direct "
+                        "equality comparison or 'key:filterop:value' where "
+                        "filterop is one of: equals, notequals, "
+                        f"contains, startswith, endswith, oneof, gte, gt, "
+                        f"lte, lt, in."
+                    )
+        return self
+
+    def get_custom_filters(
+        self, table: Type["AnySchema"]
+    ) -> List["ColumnElement[bool]"]:
+        """Get custom run metadata filters.
+
+        Args:
+            table: The query table.
+
+        Returns:
+            A list of custom filters.
+        """
+        custom_filters = super().get_custom_filters(table)
+
+        if self.run_metadata is not None:
+            from sqlmodel import exists, select
+
+            from zenml.enums import MetadataResourceTypes
+            from zenml.zen_stores.schemas import (
+                ArtifactVersionSchema,
+                ModelVersionSchema,
+                PipelineRunSchema,
+                RunMetadataResourceSchema,
+                RunMetadataSchema,
+                ScheduleSchema,
+                StepRunSchema,
+            )
+
+            resource_type_mapping = {
+                ArtifactVersionSchema: MetadataResourceTypes.ARTIFACT_VERSION,
+                ModelVersionSchema: MetadataResourceTypes.MODEL_VERSION,
+                PipelineRunSchema: MetadataResourceTypes.PIPELINE_RUN,
+                StepRunSchema: MetadataResourceTypes.STEP_RUN,
+                ScheduleSchema: MetadataResourceTypes.SCHEDULE,
+            }
+
+            # Create an EXISTS subquery for each run_metadata filter
+            for entry in self.run_metadata:
+                # Split at the first colon to get the key
+                key, value = entry.split(":", 1)
+
+                # Create an exists subquery
+                exists_subquery = exists(
+                    select(RunMetadataResourceSchema.id)
+                    .join(
+                        RunMetadataSchema,
+                        RunMetadataSchema.id  # type: ignore[arg-type]
+                        == RunMetadataResourceSchema.run_metadata_id,
+                    )
+                    .where(
+                        RunMetadataResourceSchema.resource_id == table.id,
+                        RunMetadataResourceSchema.resource_type
+                        == resource_type_mapping[table].value,
+                        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",
+                        ),
+                    )
+                )
+                custom_filters.append(exists_subquery)
+
+        return custom_filters

zenml/models/v2/core/artifact_version.py

@@ -47,6 +47,7 @@ from zenml.models.v2.base.scoped import (
     ProjectScopedResponseBody,
     ProjectScopedResponseMetadata,
     ProjectScopedResponseResources,
+    RunMetadataFilterMixin,
     TaggableFilter,
 )
 from zenml.models.v2.core.artifact import ArtifactResponse
@@ -470,12 +471,15 @@ class ArtifactVersionResponse(
 # ------------------ Filter Model ------------------
 
 
-class ArtifactVersionFilter(ProjectScopedFilter, TaggableFilter):
+class ArtifactVersionFilter(
+    ProjectScopedFilter, TaggableFilter, RunMetadataFilterMixin
+):
     """Model to enable advanced filtering of artifact versions."""
 
     FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
         *ProjectScopedFilter.FILTER_EXCLUDE_FIELDS,
         *TaggableFilter.FILTER_EXCLUDE_FIELDS,
+        *RunMetadataFilterMixin.FILTER_EXCLUDE_FIELDS,
         "artifact_id",
         "artifact",
         "only_unused",
@@ -483,17 +487,23 @@ class ArtifactVersionFilter(ProjectScopedFilter, TaggableFilter):
         "model",
         "pipeline_run",
         "model_version_id",
-        "run_metadata",
     ]
     CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = [
         *ProjectScopedFilter.CUSTOM_SORTING_OPTIONS,
         *TaggableFilter.CUSTOM_SORTING_OPTIONS,
+        *RunMetadataFilterMixin.CUSTOM_SORTING_OPTIONS,
     ]
     CLI_EXCLUDE_FIELDS: ClassVar[List[str]] = [
         *ProjectScopedFilter.CLI_EXCLUDE_FIELDS,
         *TaggableFilter.CLI_EXCLUDE_FIELDS,
+        *RunMetadataFilterMixin.CLI_EXCLUDE_FIELDS,
         "artifact_id",
     ]
+    API_MULTI_INPUT_PARAMS: ClassVar[List[str]] = [
+        *ProjectScopedFilter.API_MULTI_INPUT_PARAMS,
+        *TaggableFilter.API_MULTI_INPUT_PARAMS,
+        *RunMetadataFilterMixin.API_MULTI_INPUT_PARAMS,
+    ]
 
     artifact: Optional[Union[UUID, str]] = Field(
         default=None,
@@ -561,10 +571,6 @@ class ArtifactVersionFilter(ProjectScopedFilter, TaggableFilter):
         description="Name/ID of a pipeline run that is associated with this "
         "artifact version.",
     )
-    run_metadata: Optional[Dict[str, Any]] = Field(
-        default=None,
-        description="The run_metadata to filter the artifact versions by.",
-    )
 
     model_config = ConfigDict(protected_namespaces=())
 
@@ -590,8 +596,6 @@ class ArtifactVersionFilter(ProjectScopedFilter, TaggableFilter):
             ModelVersionArtifactSchema,
             ModelVersionSchema,
             PipelineRunSchema,
-            RunMetadataResourceSchema,
-            RunMetadataSchema,
             StepRunInputArtifactSchema,
             StepRunOutputArtifactSchema,
             StepRunSchema,
@@ -674,31 +678,6 @@ class ArtifactVersionFilter(ProjectScopedFilter, TaggableFilter):
             )
             custom_filters.append(pipeline_run_filter)
 
-        if self.run_metadata is not None:
-            from zenml.enums import MetadataResourceTypes
-
-            for key, value in self.run_metadata.items():
-                additional_filter = and_(
-                    RunMetadataResourceSchema.resource_id
-                    == ArtifactVersionSchema.id,
-                    RunMetadataResourceSchema.resource_type
-                    == 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)
-
         return custom_filters
 
     @model_validator(mode="after")

zenml/models/v2/core/model_version.py

@@ -40,14 +40,13 @@ from zenml.models.v2.base.scoped import (
     ProjectScopedResponseBody,
     ProjectScopedResponseMetadata,
     ProjectScopedResponseResources,
+    RunMetadataFilterMixin,
     TaggableFilter,
 )
 from zenml.models.v2.core.service import ServiceResponse
 from zenml.models.v2.core.tag import TagResponse
 
 if TYPE_CHECKING:
-    from sqlalchemy.sql.elements import ColumnElement
-
     from zenml.model.model import Model
     from zenml.models.v2.core.artifact_version import ArtifactVersionResponse
     from zenml.models.v2.core.model import ModelResponse
@@ -566,24 +565,33 @@ class ModelVersionResponse(
 # ------------------ Filter Model ------------------
 
 
-class ModelVersionFilter(ProjectScopedFilter, TaggableFilter):
+class ModelVersionFilter(
+    ProjectScopedFilter, TaggableFilter, RunMetadataFilterMixin
+):
     """Filter model for model versions."""
 
     FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
         *ProjectScopedFilter.FILTER_EXCLUDE_FIELDS,
         *TaggableFilter.FILTER_EXCLUDE_FIELDS,
+        *RunMetadataFilterMixin.FILTER_EXCLUDE_FIELDS,
         "model",
-        "run_metadata",
     ]
     CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = [
         *ProjectScopedFilter.CUSTOM_SORTING_OPTIONS,
         *TaggableFilter.CUSTOM_SORTING_OPTIONS,
+        *RunMetadataFilterMixin.CUSTOM_SORTING_OPTIONS,
     ]
     CLI_EXCLUDE_FIELDS: ClassVar[List[str]] = [
         *ProjectScopedFilter.CLI_EXCLUDE_FIELDS,
         *TaggableFilter.CLI_EXCLUDE_FIELDS,
+        *RunMetadataFilterMixin.CLI_EXCLUDE_FIELDS,
         "model",
     ]
+    API_MULTI_INPUT_PARAMS: ClassVar[List[str]] = [
+        *ProjectScopedFilter.API_MULTI_INPUT_PARAMS,
+        *TaggableFilter.API_MULTI_INPUT_PARAMS,
+        *RunMetadataFilterMixin.API_MULTI_INPUT_PARAMS,
+    ]
 
     name: Optional[str] = Field(
         default=None,
@@ -598,10 +606,6 @@ class ModelVersionFilter(ProjectScopedFilter, TaggableFilter):
         default=None,
         union_mode="left_to_right",
     )
-    run_metadata: Optional[Dict[str, str]] = Field(
-        default=None,
-        description="The run_metadata to filter the model versions by.",
-    )
     model: Optional[Union[str, UUID]] = Field(
         default=None,
         description="The name or ID of the model which the search is scoped "
@@ -611,48 +615,6 @@ class ModelVersionFilter(ProjectScopedFilter, TaggableFilter):
         union_mode="left_to_right",
     )
 
-    def get_custom_filters(
-        self, table: Type["AnySchema"]
-    ) -> List["ColumnElement[bool]"]:
-        """Get custom filters.
-
-        Args:
-            table: The query table.
-
-        Returns:
-            A list of custom filters.
-        """
-        custom_filters = super().get_custom_filters(table)
-
-        from sqlmodel import and_
-
-        from zenml.zen_stores.schemas import (
-            ModelVersionSchema,
-            RunMetadataResourceSchema,
-            RunMetadataSchema,
-        )
-
-        if self.run_metadata is not None:
-            from zenml.enums import MetadataResourceTypes
-
-            for key, value in self.run_metadata.items():
-                additional_filter = and_(
-                    RunMetadataResourceSchema.resource_id
-                    == ModelVersionSchema.id,
-                    RunMetadataResourceSchema.resource_type
-                    == MetadataResourceTypes.MODEL_VERSION,
-                    RunMetadataResourceSchema.run_metadata_id
-                    == RunMetadataSchema.id,
-                    self.generate_custom_query_conditions_for_column(
-                        value=value,
-                        table=RunMetadataSchema,
-                        column="value",
-                    ),
-                )
-                custom_filters.append(additional_filter)
-
-        return custom_filters
-
     def apply_filter(
         self,
         query: AnyQuery,

zenml/models/v2/core/pipeline_run.py

@@ -42,6 +42,7 @@ from zenml.models.v2.base.scoped import (
     ProjectScopedResponseBody,
     ProjectScopedResponseMetadata,
     ProjectScopedResponseResources,
+    RunMetadataFilterMixin,
     TaggableFilter,
 )
 from zenml.models.v2.core.model_version import ModelVersionResponse
@@ -582,12 +583,15 @@ class PipelineRunResponse(
 # ------------------ Filter Model ------------------
 
 
-class PipelineRunFilter(ProjectScopedFilter, TaggableFilter):
+class PipelineRunFilter(
+    ProjectScopedFilter, TaggableFilter, RunMetadataFilterMixin
+):
     """Model to enable advanced filtering of all pipeline runs."""
 
     CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = [
         *ProjectScopedFilter.CUSTOM_SORTING_OPTIONS,
         *TaggableFilter.CUSTOM_SORTING_OPTIONS,
+        *RunMetadataFilterMixin.CUSTOM_SORTING_OPTIONS,
         "tag",
         "stack",
         "pipeline",
@@ -597,6 +601,7 @@ class PipelineRunFilter(ProjectScopedFilter, TaggableFilter):
     FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
         *ProjectScopedFilter.FILTER_EXCLUDE_FIELDS,
         *TaggableFilter.FILTER_EXCLUDE_FIELDS,
+        *RunMetadataFilterMixin.FILTER_EXCLUDE_FIELDS,
         "unlisted",
         "code_repository_id",
         "build_id",
@@ -610,11 +615,16 @@ class PipelineRunFilter(ProjectScopedFilter, TaggableFilter):
         "stack_component",
         "pipeline_name",
         "templatable",
-        "run_metadata",
     ]
     CLI_EXCLUDE_FIELDS = [
         *ProjectScopedFilter.CLI_EXCLUDE_FIELDS,
         *TaggableFilter.CLI_EXCLUDE_FIELDS,
+        *RunMetadataFilterMixin.CLI_EXCLUDE_FIELDS,
+    ]
+    API_MULTI_INPUT_PARAMS: ClassVar[List[str]] = [
+        *ProjectScopedFilter.API_MULTI_INPUT_PARAMS,
+        *TaggableFilter.API_MULTI_INPUT_PARAMS,
+        *RunMetadataFilterMixin.API_MULTI_INPUT_PARAMS,
     ]
 
     name: Optional[str] = Field(
@@ -680,10 +690,6 @@ class PipelineRunFilter(ProjectScopedFilter, TaggableFilter):
         union_mode="left_to_right",
     )
     unlisted: Optional[bool] = None
-    run_metadata: Optional[Dict[str, Any]] = Field(
-        default=None,
-        description="The run_metadata to filter the pipeline runs by.",
-    )
     # TODO: Remove once frontend is ready for it. This is replaced by the more
     #   generic `pipeline` filter below.
     pipeline_name: Optional[str] = Field(
@@ -740,8 +746,6 @@ class PipelineRunFilter(ProjectScopedFilter, TaggableFilter):
             PipelineDeploymentSchema,
             PipelineRunSchema,
             PipelineSchema,
-            RunMetadataResourceSchema,
-            RunMetadataSchema,
             ScheduleSchema,
             StackComponentSchema,
             StackCompositionSchema,
@@ -899,30 +903,6 @@ class PipelineRunFilter(ProjectScopedFilter, TaggableFilter):
                 )
 
             custom_filters.append(templatable_filter)
-        if self.run_metadata is not None:
-            from zenml.enums import MetadataResourceTypes
-
-            for key, value in self.run_metadata.items():
-                additional_filter = and_(
-                    RunMetadataResourceSchema.resource_id
-                    == PipelineRunSchema.id,
-                    RunMetadataResourceSchema.resource_type
-                    == 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)
 
         return custom_filters
 

zenml/models/v2/core/service.py

@@ -31,6 +31,7 @@ from pydantic import ConfigDict, Field
 from sqlalchemy.sql.elements import ColumnElement
 
 from zenml.constants import STR_FIELD_MAX_LENGTH
+from zenml.enums import ServiceState
 from zenml.models.v2.base.base import BaseUpdate
 from zenml.models.v2.base.scoped import (
     ProjectScopedFilter,
@@ -40,8 +41,7 @@ from zenml.models.v2.base.scoped import (
     ProjectScopedResponseMetadata,
     ProjectScopedResponseResources,
 )
-from zenml.services.service_status import ServiceState
-from zenml.services.service_type import ServiceType
+from zenml.models.v2.misc.service import ServiceType
 
 if TYPE_CHECKING:
     from zenml.models.v2.core.model_version import ModelVersionResponse

zenml/models/v2/core/step_run.py

@@ -16,7 +16,6 @@
 from datetime import datetime
 from typing import (
     TYPE_CHECKING,
-    Any,
     ClassVar,
     Dict,
     List,
@@ -41,6 +40,7 @@ from zenml.models.v2.base.scoped import (
     ProjectScopedResponseBody,
     ProjectScopedResponseMetadata,
     ProjectScopedResponseResources,
+    RunMetadataFilterMixin,
 )
 from zenml.models.v2.core.artifact_version import ArtifactVersionResponse
 from zenml.models.v2.core.model_version import ModelVersionResponse
@@ -504,13 +504,25 @@ class StepRunResponse(
 # ------------------ Filter Model ------------------
 
 
-class StepRunFilter(ProjectScopedFilter):
+class StepRunFilter(ProjectScopedFilter, RunMetadataFilterMixin):
     """Model to enable advanced filtering of step runs."""
 
     FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
         *ProjectScopedFilter.FILTER_EXCLUDE_FIELDS,
+        *RunMetadataFilterMixin.FILTER_EXCLUDE_FIELDS,
         "model",
-        "run_metadata",
+    ]
+    CLI_EXCLUDE_FIELDS: ClassVar[List[str]] = [
+        *ProjectScopedFilter.CLI_EXCLUDE_FIELDS,
+        *RunMetadataFilterMixin.CLI_EXCLUDE_FIELDS,
+    ]
+    CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = [
+        *ProjectScopedFilter.CUSTOM_SORTING_OPTIONS,
+        *RunMetadataFilterMixin.CUSTOM_SORTING_OPTIONS,
+    ]
+    API_MULTI_INPUT_PARAMS: ClassVar[List[str]] = [
+        *ProjectScopedFilter.API_MULTI_INPUT_PARAMS,
+        *RunMetadataFilterMixin.API_MULTI_INPUT_PARAMS,
     ]
 
     name: Optional[str] = Field(
@@ -563,10 +575,6 @@ class StepRunFilter(ProjectScopedFilter):
         default=None,
         description="Name/ID of the model associated with the step run.",
     )
-    run_metadata: Optional[Dict[str, Any]] = Field(
-        default=None,
-        description="The run_metadata to filter the step runs by.",
-    )
     model_config = ConfigDict(protected_namespaces=())
 
     def get_custom_filters(
@@ -587,8 +595,6 @@ class StepRunFilter(ProjectScopedFilter):
         from zenml.zen_stores.schemas import (
             ModelSchema,
             ModelVersionSchema,
-            RunMetadataResourceSchema,
-            RunMetadataSchema,
             StepRunSchema,
         )
 
@@ -601,28 +607,5 @@ class StepRunFilter(ProjectScopedFilter):
                 ),
             )
             custom_filters.append(model_filter)
-        if self.run_metadata is not None:
-            from zenml.enums import MetadataResourceTypes
-
-            for key, value in self.run_metadata.items():
-                additional_filter = and_(
-                    RunMetadataResourceSchema.resource_id == StepRunSchema.id,
-                    RunMetadataResourceSchema.resource_type
-                    == MetadataResourceTypes.STEP_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)
 
         return custom_filters

zenml/{services/service_type.py → models/v2/misc/service.py}

@@ -11,7 +11,7 @@
 #  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.
-"""Implementation of a ZenML ServiceType class."""
+"""Misc models for services."""
 
 from pydantic import BaseModel, ConfigDict
 

zenml/orchestrators/step_run_utils.py

@@ -352,7 +352,7 @@ def log_model_version_dashboard_url(
     """
     from zenml.utils.dashboard_utils import get_model_version_url
 
-    if model_version_url := get_model_version_url(model_version.id):
+    if model_version_url := get_model_version_url(model_version):
         logger.info(
             "Dashboard URL for Model Version `%s (%s)`:\n%s",
             model_version.model.name,

zenml/orchestrators/utils.py

@@ -184,7 +184,7 @@ def get_config_environment_vars(
                         "service account API key to authenticate to the ZenML "
                         "server instead of your regular user account. For more "
                         "information, see "
-                        "https://docs.zenml.io/how-to/connecting-to-zenml/connect-with-a-service-account"
+                        "https://docs.zenml.io/how-to/manage-zenml-server/connecting-to-zenml/connect-with-a-service-account"
                     )
 
                 # The schedule, pipeline run or step run credentials are scoped to

zenml/services/__init__.py

@@ -51,19 +51,17 @@ from zenml.services.service_monitor import (
     TCPEndpointHealthMonitor,
     TCPEndpointHealthMonitorConfig,
 )
-from zenml.services.service_status import ServiceState, ServiceStatus
-from zenml.services.service_type import ServiceType
-
+from zenml.services.service_status import ServiceStatus
+from zenml.enums import ServiceState
+from zenml.models.v2.misc.service import ServiceType
 
 __all__ = [
-    "ServiceState",
     "ServiceConfig",
     "ServiceStatus",
     "ServiceEndpointProtocol",
     "ServiceEndpointConfig",
     "ServiceEndpointStatus",
     "BaseServiceEndpoint",
-    "ServiceType",
     "BaseService",
     "ServiceEndpointHealthMonitorConfig",
     "BaseServiceEndpointHealthMonitor",

zenml/services/container/container_service.py

@@ -27,12 +27,13 @@ from docker.models.containers import Container
 from pydantic import Field
 
 from zenml.constants import ENV_ZENML_CONFIG_PATH
+from zenml.enums import ServiceState
 from zenml.logger import get_logger
 from zenml.services.container.container_service_endpoint import (
     ContainerServiceEndpoint,
 )
 from zenml.services.service import BaseService, ServiceConfig
-from zenml.services.service_status import ServiceState, ServiceStatus
+from zenml.services.service_status import ServiceStatus
 from zenml.utils import docker_utils
 from zenml.utils.io_utils import (
     create_dir_recursive_if_not_exists,

zenml/services/local/local_service.py

@@ -26,12 +26,13 @@ import psutil
 from psutil import NoSuchProcess
 from pydantic import Field
 
+from zenml.enums import ServiceState
 from zenml.logger import get_logger
 from zenml.services.local.local_service_endpoint import (
     LocalDaemonServiceEndpoint,
 )
 from zenml.services.service import BaseService, ServiceConfig
-from zenml.services.service_status import ServiceState, ServiceStatus
+from zenml.services.service_status import ServiceStatus
 from zenml.utils.io_utils import create_dir_recursive_if_not_exists
 
 logger = get_logger(__name__)

zenml/services/service.py

@@ -34,11 +34,12 @@ from uuid import UUID
 from pydantic import ConfigDict
 
 from zenml.console import console
+from zenml.enums import ServiceState
 from zenml.logger import get_logger
+from zenml.models.v2.misc.service import ServiceType
 from zenml.services.service_endpoint import BaseServiceEndpoint
 from zenml.services.service_monitor import HTTPEndpointHealthMonitor
-from zenml.services.service_status import ServiceState, ServiceStatus
-from zenml.services.service_type import ServiceType
+from zenml.services.service_status import ServiceStatus
 from zenml.utils import source_utils
 from zenml.utils.typed_model import BaseTypedModel
 

zenml/services/service_endpoint.py

@@ -16,9 +16,10 @@
 from typing import Any, Optional, Tuple
 
 from zenml.constants import DEFAULT_LOCAL_SERVICE_IP_ADDRESS
+from zenml.enums import ServiceState
 from zenml.logger import get_logger
 from zenml.services.service_monitor import BaseServiceEndpointHealthMonitor
-from zenml.services.service_status import ServiceState, ServiceStatus
+from zenml.services.service_status import ServiceStatus
 from zenml.utils.enum_utils import StrEnum
 from zenml.utils.typed_model import BaseTypedModel