zenml-nightly 0.81.0.dev20250428__py3-none-any.whl → 0.81.0.dev20250430__py3-none-any.whl

zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator_entrypoint.py

@@ -15,7 +15,7 @@
 
 import argparse
 import socket
-from typing import Any, Dict
+from typing import Any, Dict, cast
 from uuid import UUID
 
 from kubernetes import client as k8s_client
@@ -41,7 +41,10 @@ from zenml.integrations.kubernetes.orchestrators.manifest_utils import (
 from zenml.logger import get_logger
 from zenml.orchestrators import publish_utils
 from zenml.orchestrators.dag_runner import NodeStatus, ThreadedDagRunner
-from zenml.orchestrators.utils import get_config_environment_vars
+from zenml.orchestrators.utils import (
+    get_config_environment_vars,
+    get_orchestrator_run_name,
+)
 
 logger = get_logger(__name__)
 
@@ -103,8 +106,27 @@ def main() -> None:
         Raises:
             Exception: If the pod fails to start.
         """
-        # Define Kubernetes pod name.
-        pod_name = f"{orchestrator_run_id}-{step_name}"
+        step_config = deployment_config.step_configurations[step_name].config
+        settings = step_config.settings.get("orchestrator.kubernetes", None)
+        settings = KubernetesOrchestratorSettings.model_validate(
+            settings.model_dump() if settings else {}
+        )
+
+        if settings.pod_name_prefix and not orchestrator_run_id.startswith(
+            settings.pod_name_prefix
+        ):
+            max_length = (
+                kube_utils.calculate_max_pod_name_length_for_namespace(
+                    namespace=args.kubernetes_namespace
+                )
+            )
+            pod_name_prefix = get_orchestrator_run_name(
+                settings.pod_name_prefix, max_length=max_length
+            )
+            pod_name = f"{pod_name_prefix}-{step_name}"
+        else:
+            pod_name = f"{orchestrator_run_id}-{step_name}"
+
         pod_name = kube_utils.sanitize_pod_name(
             pod_name, namespace=args.kubernetes_namespace
         )
@@ -116,20 +138,6 @@ def main() -> None:
             step_name=step_name, deployment_id=deployment_config.id
         )
 
-        step_config = deployment_config.step_configurations[step_name].config
-
-        kubernetes_settings = step_config.settings.get(
-            "orchestrator.kubernetes", None
-        )
-
-        orchestrator_settings = {}
-        if kubernetes_settings is not None:
-            orchestrator_settings = kubernetes_settings.model_dump()
-
-        settings = KubernetesOrchestratorSettings.model_validate(
-            orchestrator_settings
-        )
-
         # We set some default minimum memory resource requests for the step pod
         # here if the user has not specified any, because the step pod takes up
         # some memory resources itself and, if not specified, the pod will be
@@ -274,12 +282,17 @@ def main() -> None:
     parallel_node_startup_waiting_period = (
         orchestrator.config.parallel_step_startup_waiting_period or 0.0
     )
+    settings = cast(
+        KubernetesOrchestratorSettings,
+        orchestrator.get_settings(deployment_config),
+    )
     try:
         ThreadedDagRunner(
             dag=pipeline_dag,
             run_fn=run_step_on_kubernetes,
             finalize_fn=finalize_run,
             parallel_node_startup_waiting_period=parallel_node_startup_waiting_period,
+            max_parallelism=settings.max_parallelism,
         ).run()
         logger.info("Orchestration pod completed.")
     finally:

zenml/integrations/kubernetes/orchestrators/manifest_utils.py

@@ -28,6 +28,9 @@ from zenml.integrations.airflow.orchestrators.dag_generator import (
 )
 from zenml.integrations.kubernetes.orchestrators import kube_utils
 from zenml.integrations.kubernetes.pod_settings import KubernetesPodSettings
+from zenml.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 def add_local_stores_mount(
@@ -244,6 +247,24 @@ def add_pod_settings(
     if settings.host_ipc:
         pod_spec.host_ipc = settings.host_ipc
 
+    if settings.scheduler_name:
+        pod_spec.scheduler_name = settings.scheduler_name
+
+    for key, value in settings.additional_pod_spec_args.items():
+        if not hasattr(pod_spec, key):
+            logger.warning(f"Ignoring invalid Pod Spec argument `{key}`.")
+        else:
+            if value is None:
+                continue
+
+            existing_value = getattr(pod_spec, key)
+            if isinstance(existing_value, list):
+                existing_value.extend(value)
+            elif isinstance(existing_value, dict):
+                existing_value.update(value)
+            else:
+                setattr(pod_spec, key, value)
+
 
 def build_cron_job_manifest(
     cron_expression: str,

zenml/integrations/kubernetes/pod_settings.py

@@ -13,7 +13,7 @@
 #  permissions and limitations under the License.
 """Kubernetes pod settings."""
 
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 from pydantic import field_validator
 
@@ -33,10 +33,13 @@ class KubernetesPodSettings(BaseSettings):
         volumes: Volumes to mount in the pod.
         volume_mounts: Volume mounts to apply to the pod containers.
         host_ipc: Whether to enable host IPC for the pod.
+        scheduler_name: The name of the scheduler to use for the pod.
         image_pull_secrets: Image pull secrets to use for the pod.
         labels: Labels to apply to the pod.
         env: Environment variables to apply to the container.
         env_from: Environment variables to apply to the container.
+        additional_pod_spec_args: Additional arguments to pass to the pod. These
+            will be applied to the pod spec.
     """
 
     node_selectors: Dict[str, str] = {}
@@ -47,10 +50,12 @@ class KubernetesPodSettings(BaseSettings):
     volumes: List[Dict[str, Any]] = []
     volume_mounts: List[Dict[str, Any]] = []
     host_ipc: bool = False
+    scheduler_name: Optional[str] = None
     image_pull_secrets: List[str] = []
     labels: Dict[str, str] = {}
     env: List[Dict[str, Any]] = []
     env_from: List[Dict[str, Any]] = []
+    additional_pod_spec_args: Dict[str, Any] = {}
 
     @field_validator("volumes", mode="before")
     @classmethod

zenml/integrations/numpy/__init__.py

@@ -21,7 +21,10 @@ class NumpyIntegration(Integration):
     """Definition of Numpy integration for ZenML."""
 
     NAME = NUMPY
-    REQUIREMENTS = ["numpy<2.0.0"]
+    # Support both NumPy 1.x and 2.x
+    # Note: Some other integrations (like evidently) may require NumPy <2.0
+    # until they are updated for NumPy 2.0 compatibility
+    REQUIREMENTS = ["numpy<3.0"]
 
     @classmethod
     def activate(cls) -> None:

zenml/integrations/numpy/materializers/numpy_materializer.py

@@ -15,7 +15,16 @@
 
 import os
 from collections import Counter
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, Tuple, Type
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Dict,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
 
 import numpy as np
 
@@ -36,6 +45,48 @@ DATA_FILENAME = "data.parquet"
 SHAPE_FILENAME = "shape.json"
 DATA_VAR = "data_var"
 
+# Check NumPy version for compatibility handling
+IS_NUMPY_2 = np.lib.NumpyVersion(np.__version__) >= "2.0.0"
+
+# In NumPy 2.0, np.object_ is deprecated in favor of object
+# Let's use the right type based on the NumPy version
+NUMPY_OBJECT_TYPE = object if IS_NUMPY_2 else np.object_
+
+
+def _ensure_dtype_compatibility(arr: "NDArray[Any]") -> "NDArray[Any]":
+    """Ensure consistent dtype handling across NumPy versions.
+
+    Args:
+        arr: NumPy array to ensure compatible dtype handling
+
+    Returns:
+        NumPy array with consistent dtype behavior
+    """
+    if IS_NUMPY_2:
+        return arr  # NumPy 2.0 already preserves precision
+    else:
+        # For 1.x, explicitly preserve precision when needed
+        return arr.astype(arr.dtype, copy=False)
+
+
+def _create_array(
+    data: Any, dtype: Optional[Union["np.dtype[Any]", Type[Any]]] = None
+) -> "NDArray[Any]":
+    """Create arrays with consistent behavior across NumPy versions.
+
+    Args:
+        data: Data to convert to array
+        dtype: Optional dtype to use
+
+    Returns:
+        NumPy array with consistent creation behavior
+    """
+    if IS_NUMPY_2:
+        return np.asarray(data, dtype=dtype)
+    else:
+        # In NumPy 1.x, copy behavior is different
+        return np.array(data, dtype=dtype, copy=False)
+
 
 class NumpyMaterializer(BaseMaterializer):
     """Materializer to read data to and from pandas."""
@@ -60,7 +111,9 @@ class NumpyMaterializer(BaseMaterializer):
 
         if self.artifact_store.exists(numpy_file):
             with self.artifact_store.open(numpy_file, "rb") as f:
-                return np.load(f, allow_pickle=True)
+                arr = np.load(f, allow_pickle=True)
+                # Ensure consistent dtype handling
+                return _ensure_dtype_compatibility(arr)
         elif self.artifact_store.exists(os.path.join(self.uri, DATA_FILENAME)):
             logger.warning(
                 "A legacy artifact was found. "
@@ -86,7 +139,9 @@ class NumpyMaterializer(BaseMaterializer):
                     input_stream = pa.input_stream(f)
                     data = pq.read_table(input_stream)
                 vals = getattr(data.to_pandas(), DATA_VAR).values
-                return np.reshape(vals, shape_tuple)
+                arr = np.reshape(vals, shape_tuple)
+                # Ensure consistent dtype handling
+                return _ensure_dtype_compatibility(arr)
             except ImportError:
                 raise ImportError(
                     "You have an old version of a `NumpyMaterializer` ",
@@ -101,6 +156,9 @@ class NumpyMaterializer(BaseMaterializer):
         Args:
             arr: The numpy array to write.
         """
+        # Ensure consistent dtype handling before saving
+        arr = _ensure_dtype_compatibility(arr)
+
         with self.artifact_store.open(
             os.path.join(self.uri, NUMPY_FILENAME), "wb"
         ) as f:
@@ -186,8 +244,8 @@ class NumpyMaterializer(BaseMaterializer):
         """
         if np.issubdtype(arr.dtype, np.number):
             return self._extract_numeric_metadata(arr)
-        elif np.issubdtype(arr.dtype, np.unicode_) or np.issubdtype(
-            arr.dtype, np.object_
+        elif np.issubdtype(arr.dtype, np.str_) or np.issubdtype(
+            arr.dtype, NUMPY_OBJECT_TYPE
         ):
             return self._extract_text_metadata(arr)
         else:
@@ -204,6 +262,9 @@ class NumpyMaterializer(BaseMaterializer):
         Returns:
             A dictionary of metadata.
         """
+        # Ensure consistent precision handling
+        arr = _ensure_dtype_compatibility(arr)
+
         min_val = np.min(arr).item()
         max_val = np.max(arr).item()
 
@@ -228,7 +289,15 @@ class NumpyMaterializer(BaseMaterializer):
         Returns:
             A dictionary of metadata.
         """
-        text = " ".join(arr)
+        # Convert all array elements to strings explicitly to handle
+        # mixed types and ensure NumPy 2.0 compatibility
+        str_items = [str(item) for item in arr.flat]
+        # Use dtype='U' (unicode string) instead of str to avoid type issues
+        str_arr = _create_array(str_items, dtype=np.dtype("U")).reshape(
+            arr.shape
+        )
+
+        text = " ".join(str_arr)
         words = text.split()
         word_counts = Counter(words)
         unique_words = len(word_counts)

zenml/integrations/pandas/materializers/pandas_materializer.py

@@ -15,6 +15,11 @@
 
 This materializer handles pandas DataFrame and Series objects.
 
+Special features:
+    - Handles pandas DataFrames and Series with various data types
+    - Provides helpful error messages for custom data type errors
+    - Warns when custom data types are detected that might need additional libraries
+
 Environment Variables:
     ZENML_PANDAS_SAMPLE_ROWS: Controls the number of sample rows to include in
         visualizations. Defaults to 10 if not set.
@@ -41,6 +46,32 @@ CSV_FILENAME = "df.csv"
 # Default number of sample rows to display in visualizations
 DEFAULT_SAMPLE_ROWS = 10
 
+# List of standard pandas/numpy dtype prefixes for type checking
+STANDARD_DTYPE_PREFIXES = [
+    "int",
+    "float",
+    "bool",
+    "datetime",
+    "timedelta",
+    "object",
+    "category",
+    "string",
+    "complex",
+]
+
+
+def is_standard_dtype(dtype_str: str) -> bool:
+    """Check if a dtype string represents a standard pandas/numpy dtype.
+
+    Args:
+        dtype_str: String representation of the dtype
+
+    Returns:
+        bool: True if it's a standard dtype, False otherwise
+    """
+    dtype_str = dtype_str.lower()
+    return any(prefix in dtype_str for prefix in STANDARD_DTYPE_PREFIXES)
+
 
 class PandasMaterializer(BaseMaterializer):
     """Materializer to read data to and from pandas."""
@@ -86,27 +117,60 @@ class PandasMaterializer(BaseMaterializer):
 
         Raises:
             ImportError: If pyarrow or fastparquet is not installed.
+            TypeError: Raised if there is an error when reading parquet files.
+            zenml_type_error: If the data type is a custom data type.
 
         Returns:
             The pandas dataframe or series.
         """
-        if self.artifact_store.exists(self.parquet_path):
-            if self.pyarrow_exists:
-                with self.artifact_store.open(
-                    self.parquet_path, mode="rb"
-                ) as f:
-                    df = pd.read_parquet(f)
+        try:
+            # First try normal loading
+            if self.artifact_store.exists(self.parquet_path):
+                if self.pyarrow_exists:
+                    with self.artifact_store.open(
+                        self.parquet_path, mode="rb"
+                    ) as f:
+                        df = pd.read_parquet(f)
+                else:
+                    raise ImportError(
+                        "You have an old version of a `PandasMaterializer` "
+                        "data artifact stored in the artifact store "
+                        "as a `.parquet` file, which requires `pyarrow` "
+                        "for reading, You can install `pyarrow` by running "
+                        "'`pip install pyarrow fastparquet`'."
+                    )
             else:
-                raise ImportError(
-                    "You have an old version of a `PandasMaterializer` "
-                    "data artifact stored in the artifact store "
-                    "as a `.parquet` file, which requires `pyarrow` "
-                    "for reading, You can install `pyarrow` by running "
-                    "'`pip install pyarrow fastparquet`'."
+                with self.artifact_store.open(self.csv_path, mode="rb") as f:
+                    df = pd.read_csv(f, index_col=0, parse_dates=True)
+        except TypeError as e:
+            # Check for common data type error patterns
+            error_str = str(e).lower()
+            is_dtype_error = (
+                "not understood" in error_str
+                or "no type" in error_str
+                or "cannot deserialize" in error_str
+                or "data type" in error_str
+            )
+
+            if is_dtype_error:
+                # If the error is due to a custom data type, raise a ZenML TypeError
+                # This is to avoid the original error from being swallowed
+                # and to provide a more helpful error message
+                zenml_type_error = TypeError(
+                    "Encountered an error with custom data types. This may be due to "
+                    "missing libraries that were used when the data was originally created. "
+                    "For example, you might need to install libraries like 'geopandas' for "
+                    "GeoPandas data types, 'pandas-gbq' for BigQuery data types, or "
+                    "'pyarrow' for Arrow data types. Make sure to import these libraries "
+                    "in your step code as well as adding them to your step requirements, "
+                    "even if you're not directly using them in your code. Pandas needs "
+                    "these libraries to be imported to properly load the custom data types. "
+                    "Try installing any packages that were used in previous pipeline steps "
+                    "but might not be available in the current environment."
                 )
-        else:
-            with self.artifact_store.open(self.csv_path, mode="rb") as f:
-                df = pd.read_csv(f, index_col=0, parse_dates=True)
+                raise zenml_type_error from e
+            # We don't know how to handle this error, so re-raise the original error
+            raise e
 
         # validate the type of the data.
         def is_dataframe_or_series(
@@ -204,14 +268,46 @@ class PandasMaterializer(BaseMaterializer):
         Returns:
             The extracted metadata as a dictionary.
         """
-        pandas_metadata: Dict[str, "MetadataType"] = {"shape": df.shape}
+        # Store whether it's a Series for later reference
+        is_series = isinstance(df, pd.Series)
 
-        if isinstance(df, pd.Series):
-            pandas_metadata["dtype"] = DType(df.dtype.type)
-            pandas_metadata["mean"] = float(df.mean().item())
-            pandas_metadata["std"] = float(df.std().item())
-            pandas_metadata["min"] = float(df.min().item())
-            pandas_metadata["max"] = float(df.max().item())
+        # Store original shape before conversion
+        original_shape = df.shape
+
+        # Convert Series to DataFrame for consistent handling of dtypes
+        if is_series:
+            series_obj = df  # Keep original Series for some calculations
+            df = df.to_frame(name="series")
+
+        pandas_metadata: Dict[str, "MetadataType"] = {"shape": original_shape}
+
+        # Add information about custom data types to metadata
+        custom_types = {}
+        try:
+            for col, dtype in df.dtypes.items():
+                dtype_str = str(dtype)
+                if not is_standard_dtype(dtype_str):
+                    col_name = "series" if is_series else str(col)
+                    custom_types[col_name] = dtype_str
+                    # Try to get module information if available
+                    try:
+                        module_name = dtype.type.__module__
+                        custom_types[f"{col_name}_module"] = module_name
+                    except (AttributeError, TypeError):
+                        pass
+
+            if custom_types:
+                pandas_metadata["custom_types"] = custom_types
+        except Exception as e:
+            logger.debug(f"Error extracting custom type metadata: {e}")
+
+        if is_series:
+            # For Series, use the original series object for statistics
+            pandas_metadata["dtype"] = DType(series_obj.dtype.type)
+            pandas_metadata["mean"] = float(series_obj.mean().item())
+            pandas_metadata["std"] = float(series_obj.std().item())
+            pandas_metadata["min"] = float(series_obj.min().item())
+            pandas_metadata["max"] = float(series_obj.max().item())
 
         else:
             pandas_metadata["dtype"] = {

zenml/integrations/tekton/orchestrators/tekton_orchestrator.py

@@ -524,36 +524,16 @@ class TektonOrchestrator(ContainerizedOrchestrator):
                 node_selector_constraint: Optional[Tuple[str, str]] = None
                 pod_settings = step_settings.pod_settings
                 if pod_settings:
-                    if pod_settings.host_ipc:
+                    ignored_fields = pod_settings.model_fields_set - {
+                        "node_selectors"
+                    }
+                    if ignored_fields:
                         logger.warning(
-                            "Host IPC is set to `True` but not supported in "
-                            "this orchestrator. Ignoring..."
-                        )
-                    if pod_settings.affinity:
-                        logger.warning(
-                            "Affinity is set but not supported in Tekton with "
-                            "Tekton Pipelines 2.x. Ignoring..."
-                        )
-                    if pod_settings.tolerations:
-                        logger.warning(
-                            "Tolerations are set but not supported in "
-                            "Tekton with Tekton Pipelines 2.x. Ignoring..."
-                        )
-                    if pod_settings.volumes:
-                        logger.warning(
-                            "Volumes are set but not supported in Tekton with "
-                            "Tekton Pipelines 2.x. Ignoring..."
-                        )
-                    if pod_settings.volume_mounts:
-                        logger.warning(
-                            "Volume mounts are set but not supported in "
-                            "Tekton with Tekton Pipelines 2.x. Ignoring..."
-                        )
-                    if pod_settings.env or pod_settings.env_from:
-                        logger.warning(
-                            "Environment variables are set but not supported "
-                            "in Tekton with Tekton Pipelines 2.x. Ignoring..."
+                            f"The following pod settings are not supported in "
+                            f"Tekton with Tekton Pipelines 2.x and will be "
+                            f"ignored: {list(ignored_fields)}."
                         )
+
                     # apply pod settings
                     if (
                         KFP_ACCELERATOR_NODE_SELECTOR_CONSTRAINT_LABEL

zenml/models/v2/core/model_version.py

@@ -31,7 +31,6 @@ from zenml.constants import STR_FIELD_MAX_LENGTH, TEXT_FIELD_MAX_LENGTH
 from zenml.enums import ArtifactType, ModelStages
 from zenml.metadata.metadata_types import MetadataType
 from zenml.models.v2.base.base import BaseUpdate
-from zenml.models.v2.base.filter import AnyQuery
 from zenml.models.v2.base.page import Page
 from zenml.models.v2.base.scoped import (
     ProjectScopedFilter,
@@ -47,11 +46,15 @@ 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
     from zenml.models.v2.core.pipeline_run import PipelineRunResponse
-    from zenml.zen_stores.schemas import BaseSchema
+    from zenml.zen_stores.schemas import (
+        BaseSchema,
+    )
 
     AnySchema = TypeVar("AnySchema", bound=BaseSchema)
 
@@ -585,7 +588,6 @@ class ModelVersionFilter(
         *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,
@@ -615,41 +617,34 @@ class ModelVersionFilter(
         union_mode="left_to_right",
     )
 
-    def apply_filter(
-        self,
-        query: AnyQuery,
-        table: Type["AnySchema"],
-    ) -> AnyQuery:
-        """Applies the filter to a query.
+    def get_custom_filters(
+        self, table: Type["AnySchema"]
+    ) -> List[Union["ColumnElement[bool]"]]:
+        """Get custom filters.
 
         Args:
-            query: The query to which to apply the filter.
             table: The query table.
 
         Returns:
-            The query with filter applied.
-
-        Raises:
-            ValueError: if the filter is not scoped to a model.
+            A list of custom filters.
         """
-        query = super().apply_filter(query=query, table=table)
-
-        # The model scope must always be set and must be a UUID. If the
-        # client sets this to a string, the server will try to resolve it to a
-        # model ID.
-        #
-        # If not set by the client, the server will raise a ValueError.
-        #
-        # See: SqlZenStore._set_filter_model_id
-
-        if not self.model:
-            raise ValueError("Model scope missing from the filter.")
-
-        if not isinstance(self.model, UUID):
-            raise ValueError(
-                f"Model scope must be a UUID, got {type(self.model)}."
-            )
+        from sqlalchemy import and_
+
+        from zenml.zen_stores.schemas import (
+            ModelSchema,
+            ModelVersionSchema,
+        )
 
-        query = query.where(getattr(table, "model_id") == self.model)
+        custom_filters = super().get_custom_filters(table)
+
+        if self.model:
+            value, operator = self._resolve_operator(self.model)
+            model_filter = and_(
+                ModelVersionSchema.model_id == ModelSchema.id,  # type: ignore[arg-type]
+                self.generate_name_or_id_query_conditions(
+                    value=self.model, table=ModelSchema
+                ),
+            )
+            custom_filters.append(model_filter)
 
-        return query
+        return custom_filters

zenml/models/v2/core/pipeline_deployment.py

@@ -13,7 +13,7 @@
 #  permissions and limitations under the License.
 """Models representing pipeline deployments."""
 
-from typing import Dict, Optional, TypeVar, Union
+from typing import Any, Dict, Optional, TypeVar, Union
 from uuid import UUID
 
 from pydantic import Field
@@ -60,7 +60,7 @@ class PipelineDeploymentBase(BaseZenModel):
     step_configurations: Dict[str, Step] = Field(
         default={}, title="The step configurations for this deployment."
     )
-    client_environment: Dict[str, str] = Field(
+    client_environment: Dict[str, Any] = Field(
         default={}, title="The client environment for this deployment."
     )
     client_version: Optional[str] = Field(
@@ -143,7 +143,7 @@ class PipelineDeploymentResponseMetadata(ProjectScopedResponseMetadata):
     step_configurations: Dict[str, Step] = Field(
         default={}, title="The step configurations for this deployment."
     )
-    client_environment: Dict[str, str] = Field(
+    client_environment: Dict[str, Any] = Field(
         default={}, title="The client environment for this deployment."
     )
     client_version: Optional[str] = Field(
@@ -242,7 +242,7 @@ class PipelineDeploymentResponse(
         return self.get_metadata().step_configurations
 
     @property
-    def client_environment(self) -> Dict[str, str]:
+    def client_environment(self) -> Dict[str, Any]:
         """The `client_environment` property.
 
         Returns: