snowflake-ml-python 1.20.0__py3-none-any.whl → 1.22.0__py3-none-any.whl

snowflake/ml/model/_packager/model_handlers/xgboost.py

@@ -194,7 +194,18 @@ class XGBModelHandler(_base.BaseModelHandler[Union["xgboost.Booster", "xgboost.X
 
         if kwargs.get("use_gpu", False):
             assert type(kwargs.get("use_gpu", False)) == bool
-            gpu_params = {"tree_method": "gpu_hist", "predictor": "gpu_predictor"}
+            from packaging import version
+
+            xgb_version = version.parse(xgboost.__version__)
+            if xgb_version >= version.parse("3.1.0"):
+                # XGBoost 3.1.0+: Use device="cuda" for GPU acceleration
+                # gpu_hist and gpu_predictor were removed in XGBoost 3.1.0
+                # See: https://xgboost.readthedocs.io/en/latest/changes/v3.1.0.html
+                gpu_params = {"tree_method": "hist", "device": "cuda"}
+            else:
+                # XGBoost < 3.1.0: Use legacy gpu_hist tree_method
+                gpu_params = {"tree_method": "gpu_hist", "predictor": "gpu_predictor"}
+
             if isinstance(m, xgboost.Booster):
                 m.set_param(gpu_params)
             elif isinstance(m, xgboost.XGBModel):
@@ -256,6 +267,20 @@ class XGBModelHandler(_base.BaseModelHandler[Union["xgboost.Booster", "xgboost.X
                 @custom_model.inference_api
                 def explain_fn(self: custom_model.CustomModel, X: pd.DataFrame) -> pd.DataFrame:
                     import shap
+                    from packaging import version
+
+                    xgb_version = version.parse(xgboost.__version__)
+                    shap_version = version.parse(shap.__version__)
+
+                    # SHAP < 0.50.0 is incompatible with XGBoost >= 3.1.0 due to base_score format change
+                    # (base_score is now stored as a vector for multi-output models)
+                    # See: https://xgboost.readthedocs.io/en/latest/changes/v3.1.0.html
+                    if xgb_version >= version.parse("3.1.0") and shap_version < version.parse("0.50.0"):
+                        raise RuntimeError(
+                            f"SHAP version {shap.__version__} is incompatible with XGBoost version "
+                            f"{xgboost.__version__}. XGBoost 3.1+ changed the model format which requires "
+                            f"SHAP >= 0.50.0. Please upgrade SHAP or use XGBoost < 3.1."
+                        )
 
                     explainer = shap.TreeExplainer(raw_model)
                     df = handlers_utils.convert_explanations_to_2D_df(raw_model, explainer.shap_values(X))

snowflake/ml/model/_packager/model_meta/model_meta.py

@@ -20,6 +20,7 @@ from snowflake.ml.model._packager.model_env import model_env
 from snowflake.ml.model._packager.model_meta import model_blob_meta, model_meta_schema
 from snowflake.ml.model._packager.model_meta_migrator import migrator_plans
 from snowflake.ml.model._packager.model_runtime import model_runtime
+from snowflake.ml.model.code_path import CodePath
 
 MODEL_METADATA_FILE = "model.yaml"
 MODEL_CODE_DIR = "code"
@@ -39,7 +40,7 @@ def create_model_metadata(
     signatures: Optional[dict[str, model_signature.ModelSignature]] = None,
     function_properties: Optional[dict[str, dict[str, Any]]] = None,
     metadata: Optional[dict[str, str]] = None,
-    code_paths: Optional[list[str]] = None,
+    code_paths: Optional[list[model_types.CodePathLike]] = None,
     ext_modules: Optional[list[ModuleType]] = None,
     conda_dependencies: Optional[list[str]] = None,
     pip_requirements: Optional[list[str]] = None,
@@ -77,7 +78,8 @@ def create_model_metadata(
         **kwargs: Dict of attributes and values of the metadata. Used when loading from file.
 
     Raises:
-        ValueError: Raised when the code path contains reserved file or directory.
+        ValueError: Raised when the code path contains reserved file or directory, or destination conflicts.
+        FileNotFoundError: Raised when a code path does not exist.
 
     Yields:
         A model metadata object.
@@ -134,13 +136,44 @@ def create_model_metadata(
         os.makedirs(code_dir_path, exist_ok=True)
 
     if code_paths:
+        # Resolve all code paths and check for conflicts
+        resolved_paths: list[tuple[str, str]] = []  # (source, destination_relative)
         for code_path in code_paths:
-            # This part is to prevent users from providing code following our naming and overwrite our code.
-            if (
-                os.path.isfile(code_path) and os.path.splitext(os.path.basename(code_path))[0] == _SNOWFLAKE_PKG_NAME
-            ) or (os.path.isdir(code_path) and os.path.basename(code_path) == _SNOWFLAKE_PKG_NAME):
+            if isinstance(code_path, CodePath):
+                source, dest_relative = code_path._resolve()
+            else:
+                # String path: keep existing behavior
+                source = os.path.normpath(os.path.abspath(code_path))
+                if not os.path.exists(source):
+                    raise FileNotFoundError(f"Code path '{code_path}' does not exist (resolved to {source}).")
+                dest_relative = os.path.basename(source)
+            resolved_paths.append((source, dest_relative))
+
+        # Check for destination conflicts
+        seen: dict[str, str] = {}
+        for source, dest in resolved_paths:
+            if dest in seen:
+                raise ValueError(
+                    f"Destination path conflict: '{dest}' is targeted by both '{seen[dest]}' and '{source}'."
+                )
+            seen[dest] = source
+
+        # Copy files
+        for source, dest_relative in resolved_paths:
+            # Prevent reserved name conflicts
+            dest_name = dest_relative.split(os.sep)[0] if os.sep in dest_relative else dest_relative
+            if (os.path.isfile(source) and os.path.splitext(dest_name)[0] == _SNOWFLAKE_PKG_NAME) or (
+                os.path.isdir(source) and dest_name == _SNOWFLAKE_PKG_NAME
+            ):
                 raise ValueError("`snowflake` is a reserved name and you cannot contain that into code path.")
-            file_utils.copy_file_or_tree(code_path, code_dir_path)
+
+            parent_dir = (
+                os.path.join(code_dir_path, os.path.dirname(dest_relative))
+                if os.path.dirname(dest_relative)
+                else code_dir_path
+            )
+            os.makedirs(parent_dir, exist_ok=True)
+            file_utils.copy_file_or_tree(source, parent_dir)
 
     try:
         imported_modules = []

snowflake/ml/model/_packager/model_packager.py

@@ -49,7 +49,7 @@ class ModelPackager:
         target_platforms: Optional[list[model_types.TargetPlatform]] = None,
         python_version: Optional[str] = None,
         ext_modules: Optional[list[ModuleType]] = None,
-        code_paths: Optional[list[str]] = None,
+        code_paths: Optional[list[model_types.CodePathLike]] = None,
         options: model_types.ModelSaveOption,
         task: model_types.Task = model_types.Task.UNKNOWN,
     ) -> model_meta.ModelMetadata:

snowflake/ml/model/_signatures/core.py

@@ -191,6 +191,35 @@ class DataType(Enum):
             original_exception=NotImplementedError(f"Type {snowpark_type} is not supported as a DataType."),
         )
 
+    @classmethod
+    def from_python_type(cls, python_type: type) -> "DataType":
+        """Translate Python built-in type to DataType for signature definition.
+
+        Args:
+            python_type: A Python built-in type (int, float, str, bool).
+
+        Raises:
+            SnowflakeMLException: NotImplementedError: Raised when the given Python type is not supported.
+
+        Returns:
+            Corresponding DataType.
+        """
+        python_to_snowml_type_mapping: dict[type, "DataType"] = {
+            int: DataType.INT64,
+            float: DataType.DOUBLE,
+            str: DataType.STRING,
+            bool: DataType.BOOL,
+        }
+        if python_type in python_to_snowml_type_mapping:
+            return python_to_snowml_type_mapping[python_type]
+        raise snowml_exceptions.SnowflakeMLException(
+            error_code=error_codes.NOT_IMPLEMENTED,
+            original_exception=NotImplementedError(
+                f"Python type {python_type} is not supported as a DataType. "
+                f"Supported types are: {list(python_to_snowml_type_mapping.keys())}."
+            ),
+        )
+
 
 class BaseFeatureSpec(ABC):
     """Abstract Class for specification of a feature."""
@@ -481,10 +510,280 @@ class FeatureGroupSpec(BaseFeatureSpec):
         return FeatureGroupSpec(name=input_dict["name"], specs=specs, shape=shape)
 
 
+class BaseParamSpec(ABC):
+    """Abstract Class for specification of a parameter."""
+
+    def __init__(self, name: str, shape: Optional[tuple[int, ...]] = None) -> None:
+        self._name = name
+
+        if shape is not None and not isinstance(shape, tuple):
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_TYPE,
+                original_exception=TypeError("Shape should be a tuple if presented."),
+            )
+        self._shape = shape
+
+    @final
+    @property
+    def name(self) -> str:
+        """Name of the parameter."""
+        return self._name
+
+    @final
+    @property
+    def shape(self) -> Optional[tuple[int, ...]]:
+        """Shape of the parameter. None means scalar."""
+        return self._shape
+
+    @abstractmethod
+    def to_dict(self) -> dict[str, Any]:
+        """Serialization"""
+
+    @classmethod
+    @abstractmethod
+    def from_dict(cls, input_dict: dict[str, Any]) -> "BaseParamSpec":
+        """Deserialization"""
+
+
+class ParamSpec(BaseParamSpec):
+    """Specification of a parameter in Snowflake native model packaging."""
+
+    def __init__(
+        self,
+        name: str,
+        dtype: DataType,
+        default_value: Any,
+        shape: Optional[tuple[int, ...]] = None,
+    ) -> None:
+        """Initialize a parameter.
+
+        Args:
+            name: Name of the parameter.
+            dtype: Type of the parameter.
+            default_value: Default value of the parameter.
+            shape: Shape of the parameter. None means scalar, otherwise a tuple
+                representing dimensions. Use -1 for variable length dimensions.
+        """
+        super().__init__(name=name, shape=shape)
+
+        self._validate_default_value(dtype, default_value, shape)
+        self._dtype = dtype
+        self._default_value = default_value
+
+    @staticmethod
+    def _validate_default_value(dtype: DataType, default_value: Any, shape: Optional[tuple[int, ...]]) -> None:
+        """Validate that default_value is compatible with dtype and shape.
+
+        Args:
+            dtype: The expected data type.
+            default_value: The default value to validate. None is allowed and means no default.
+            shape: The expected shape. None means scalar.
+
+        Raises:
+            SnowflakeMLException: ValueError: When the default_value is not compatible with dtype/shape.
+        """
+        if default_value is None:
+            return
+
+        try:
+            arr = np.array(default_value, dtype=dtype._numpy_type)
+
+            # Validate shape compatibility
+            if shape is None:
+                # Scalar expected
+                if arr.ndim != 0:
+                    raise snowml_exceptions.SnowflakeMLException(
+                        error_code=error_codes.INVALID_ARGUMENT,
+                        original_exception=ValueError(f"Expected scalar value, got array with shape {arr.shape}"),
+                    )
+            else:
+                # Non-scalar expected
+                if arr.ndim != len(shape):
+                    raise snowml_exceptions.SnowflakeMLException(
+                        error_code=error_codes.INVALID_ARGUMENT,
+                        original_exception=ValueError(
+                            f"Expected {len(shape)}-dimensional value, got {arr.ndim}-dimensional"
+                        ),
+                    )
+                # Check each dimension (-1 means variable length)
+                for i, (expected, actual) in enumerate(zip(shape, arr.shape)):
+                    if expected != -1 and expected != actual:
+                        raise snowml_exceptions.SnowflakeMLException(
+                            error_code=error_codes.INVALID_ARGUMENT,
+                            original_exception=ValueError(f"Dimension {i}: expected {expected}, got {actual}"),
+                        )
+
+        except (ValueError, TypeError, OverflowError) as e:
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_ARGUMENT,
+                original_exception=ValueError(
+                    f"Default value {repr(default_value)} (type: {type(default_value).__name__}) "
+                    f"is not compatible with dtype {dtype} and shape {shape}. {str(e)}"
+                ),
+            )
+
+    @property
+    def dtype(self) -> DataType:
+        """Type of the parameter."""
+        return self._dtype
+
+    @property
+    def default_value(self) -> Any:
+        """Default value of the parameter."""
+        return self._default_value
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize the parameter specification into a dict.
+
+        Returns:
+            A dict that serializes the parameter specification.
+        """
+        result: dict[str, Any] = {
+            "name": self._name,
+            "dtype": self._dtype.name,
+            "default_value": self._default_value,
+        }
+        if self._shape is not None:
+            result["shape"] = self._shape
+        return result
+
+    @classmethod
+    def from_dict(cls, input_dict: dict[str, Any]) -> "ParamSpec":
+        """Deserialize the parameter specification from a dict.
+
+        Args:
+            input_dict: The dict containing information of the parameter specification.
+
+        Returns:
+            ParamSpec: The deserialized parameter specification.
+        """
+        shape = input_dict.get("shape", None)
+        if shape is not None:
+            shape = tuple(shape)
+        return ParamSpec(
+            name=input_dict["name"],
+            dtype=DataType[input_dict["dtype"]],
+            default_value=input_dict["default_value"],
+            shape=shape,
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, ParamSpec):
+            return (
+                self._name == other._name
+                and self._dtype == other._dtype
+                and np.array_equal(self._default_value, other._default_value)
+                and self._shape == other._shape
+            )
+        else:
+            return False
+
+    def __repr__(self) -> str:
+        shape_str = f", shape={repr(self._shape)}" if self._shape else ""
+        return (
+            f"ParamSpec(name={repr(self._name)}, dtype={repr(self._dtype)}, "
+            f"default_value={repr(self._default_value)}{shape_str})"
+        )
+
+    @classmethod
+    def from_mlflow_spec(cls, param_spec: "mlflow.types.ParamSpec") -> "ParamSpec":
+        return ParamSpec(
+            name=param_spec.name,
+            dtype=DataType.from_numpy_type(param_spec.dtype.to_numpy()),
+            default_value=param_spec.default,
+        )
+
+
+class ParamGroupSpec(BaseParamSpec):
+    """Specification of a group of parameters in Snowflake native model packaging."""
+
+    def __init__(
+        self,
+        name: str,
+        specs: list[BaseParamSpec],
+        shape: Optional[tuple[int, ...]] = None,
+    ) -> None:
+        """Initialize a parameter group.
+
+        Args:
+            name: Name of the parameter group.
+            specs: A list of parameter specifications that composes the group.
+            shape: Shape of the parameter group. None means scalar, otherwise a tuple
+                representing dimensions. Use -1 for variable length dimensions.
+        """
+        super().__init__(name=name, shape=shape)
+        self._specs = specs
+        self._validate()
+
+    def _validate(self) -> None:
+        if len(self._specs) == 0:
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_ARGUMENT, original_exception=ValueError("No children param specs.")
+            )
+
+    @property
+    def specs(self) -> list[BaseParamSpec]:
+        """List of parameter specifications in the group."""
+        return self._specs
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, ParamGroupSpec):
+            return self._name == other._name and self._specs == other._specs and self._shape == other._shape
+        return False
+
+    def __repr__(self) -> str:
+        spec_strs = ",\n\t\t".join(repr(spec) for spec in self._specs)
+        shape_str = f",\nshape={repr(self._shape)}" if self._shape else ""
+        return textwrap.dedent(
+            f"""ParamGroupSpec(
+                name={repr(self._name)},
+                specs=[
+                    {spec_strs}
+                ]{shape_str}
+            )
+            """
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize the parameter group into a dict.
+
+        Returns:
+            A dict that serializes the parameter group.
+        """
+        result: dict[str, Any] = {"name": self._name, "specs": [s.to_dict() for s in self._specs]}
+        if self._shape is not None:
+            result["shape"] = self._shape
+        return result
+
+    @classmethod
+    def from_dict(cls, input_dict: dict[str, Any]) -> "ParamGroupSpec":
+        """Deserialize the parameter group from a dict.
+
+        Args:
+            input_dict: The dict containing information of the parameter group.
+
+        Returns:
+            A parameter group instance deserialized and created from the dict.
+        """
+        specs: list[BaseParamSpec] = []
+        for e in input_dict["specs"]:
+            spec: BaseParamSpec = ParamGroupSpec.from_dict(e) if "specs" in e else ParamSpec.from_dict(e)
+            specs.append(spec)
+        shape = input_dict.get("shape", None)
+        if shape is not None:
+            shape = tuple(shape)
+        return ParamGroupSpec(name=input_dict["name"], specs=specs, shape=shape)
+
+
 class ModelSignature:
     """Signature of a model that specifies the input and output of a model."""
 
-    def __init__(self, inputs: Sequence[BaseFeatureSpec], outputs: Sequence[BaseFeatureSpec]) -> None:
+    def __init__(
+        self,
+        inputs: Sequence[BaseFeatureSpec],
+        outputs: Sequence[BaseFeatureSpec],
+        params: Optional[Sequence[BaseParamSpec]] = None,
+    ) -> None:
         """Initialize a model signature.
 
         Args:
@@ -492,9 +791,19 @@ class ModelSignature:
                 the input of the model.
             outputs: A sequence of feature specifications and feature group specifications that will compose
                 the output of the model.
+            params: A sequence of parameter specifications and parameter group specifications that will compose
+                the parameters of the model. Defaults to None.
+
+        Raises:
+            SnowflakeMLException: ValueError: When the parameters have duplicate names or the same
+                names as input features.
+
+        # noqa: DAR402
         """
         self._inputs = inputs
         self._outputs = outputs
+        self._params = params or []
+        self._name_validation()
 
     @property
     def inputs(self) -> Sequence[BaseFeatureSpec]:
@@ -506,9 +815,18 @@ class ModelSignature:
         """Outputs of the model, containing a sequence of feature specifications and feature group specifications."""
         return self._outputs
 
+    @property
+    def params(self) -> Sequence[BaseParamSpec]:
+        """Parameters of the model, containing a sequence of parameter specifications."""
+        return self._params
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, ModelSignature):
-            return self._inputs == other._inputs and self._outputs == other._outputs
+            return (
+                self._inputs == other._inputs
+                and self._outputs == other._outputs
+                and getattr(other, "_params", []) == self._params  # handles backward compatibility
+            )
         else:
             return False
 
@@ -522,6 +840,7 @@ class ModelSignature:
         return {
             "inputs": [spec.to_dict() for spec in self._inputs],
             "outputs": [spec.to_dict() for spec in self._outputs],
+            "params": [spec.to_dict() for spec in self._params],
         }
 
     @classmethod
@@ -536,18 +855,26 @@ class ModelSignature:
         """
         sig_outs = loaded["outputs"]
         sig_inputs = loaded["inputs"]
+        # If parameters is not provided, default to empty list for backward compatibility.
+        sig_params = loaded.get("params", [])
 
         deserialize_spec: Callable[[dict[str, Any]], BaseFeatureSpec] = lambda sig_spec: (
             FeatureGroupSpec.from_dict(sig_spec) if "specs" in sig_spec else FeatureSpec.from_dict(sig_spec)
         )
+        deserialize_param: Callable[[dict[str, Any]], BaseParamSpec] = lambda sig_param: (
+            ParamGroupSpec.from_dict(sig_param) if "specs" in sig_param else ParamSpec.from_dict(sig_param)
+        )
 
         return ModelSignature(
-            inputs=[deserialize_spec(s) for s in sig_inputs], outputs=[deserialize_spec(s) for s in sig_outs]
+            inputs=[deserialize_spec(s) for s in sig_inputs],
+            outputs=[deserialize_spec(s) for s in sig_outs],
+            params=[deserialize_param(s) for s in sig_params],
         )
 
     def __repr__(self) -> str:
         inputs_spec_strs = ",\n\t\t".join(repr(spec) for spec in self._inputs)
         outputs_spec_strs = ",\n\t\t".join(repr(spec) for spec in self._outputs)
+        params_spec_strs = ",\n\t\t".join(repr(spec) for spec in self._params)
         return textwrap.dedent(
             f"""ModelSignature(
                     inputs=[
@@ -555,6 +882,9 @@ class ModelSignature:
                     ],
                     outputs=[
                         {outputs_spec_strs}
+                    ],
+                    params=[
+                        {params_spec_strs}
                     ]
                 )"""
         )
@@ -570,19 +900,70 @@ class ModelSignature:
         # Create collapsible sections for inputs and outputs
         inputs_content = html_utils.create_features_html(self.inputs, "Input")
         outputs_content = html_utils.create_features_html(self.outputs, "Output")
-
+        params_content = html_utils.create_parameters_html(self.params, "Parameter")
         inputs_section = html_utils.create_collapsible_section("Inputs", inputs_content, open_by_default=True)
         outputs_section = html_utils.create_collapsible_section("Outputs", outputs_content, open_by_default=True)
+        params_section = html_utils.create_collapsible_section("Parameters", params_content, open_by_default=True)
 
         content = f"""
-        <div style="margin-top: 10px;">
-            {inputs_section}
-            {outputs_section}
-        </div>
+            <div style="margin-top: 10px;">
+                {inputs_section}
+                {outputs_section}
+                {params_section}
+            </div>
         """
 
         return html_utils.create_base_container("Model Signature", content)
 
+    def _name_validation(self) -> None:
+        """Validate the names of the inputs and parameters.
+
+        Names are compared case-insensitively (matches Snowflake identifier behavior).
+
+        Raises:
+            SnowflakeMLException: ValueError: When the parameters have duplicate names or the same
+                names as input features.
+        """
+        input_names: set[str] = set()
+        for input_spec in self._inputs:
+            names = (
+                [input_spec.name.upper() for spec in input_spec._specs]
+                if isinstance(input_spec, FeatureGroupSpec)
+                else [input_spec.name.upper()]
+            )
+            input_names.update(names)
+
+        param_names: set[str] = set()
+        dup_params: set[str] = set()
+        collision_names: set[str] = set()
+
+        for param in self._params:
+            names = [spec.name for spec in param.specs] if isinstance(param, ParamGroupSpec) else [param.name]
+            for name in names:
+                if name.upper() in param_names:
+                    dup_params.add(name)
+                if name.upper() in input_names:
+                    collision_names.add(name)
+                param_names.add(name.upper())
+
+        if dup_params:
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_ARGUMENT,
+                original_exception=ValueError(
+                    f"Found duplicate parameter named resolved as {', '.join(sorted(dup_params))}."
+                    " Parameters must have distinct names (case-insensitive)."
+                ),
+            )
+
+        if collision_names:
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_ARGUMENT,
+                original_exception=ValueError(
+                    f"Found parameter(s) with the same name as input feature(s): {', '.join(sorted(collision_names))}."
+                    " Parameters and inputs must have distinct names (case-insensitive)."
+                ),
+            )
+
     @classmethod
     def from_mlflow_sig(cls, mlflow_sig: "mlflow.models.ModelSignature") -> "ModelSignature":
         return ModelSignature(
@@ -593,4 +974,5 @@ class ModelSignature:
                 FeatureSpec.from_mlflow_spec(spec, f"output_feature_{idx}")
                 for idx, spec in enumerate(mlflow_sig.outputs)
             ],
+            params=[ParamSpec.from_mlflow_spec(spec) for spec in mlflow_sig.params or []],
         )

snowflake/ml/model/_signatures/utils.py

@@ -20,15 +20,21 @@ def convert_list_to_ndarray(data: list[Any]) -> npt.NDArray[Any]:
 
     Raises:
         SnowflakeMLException: ValueError: Raised when ragged nested list or list containing non-basic type confronted.
-        SnowflakeMLException: ValueError: Raised when ragged nested list or list containing non-basic type confronted.
 
     Returns:
         The converted numpy array.
     """
-    warnings.filterwarnings("error", category=np.VisibleDeprecationWarning)
+    # VisibleDeprecationWarning was removed in numpy>2
+    visible_deprecation_warning = getattr(np, "VisibleDeprecationWarning", None)
+    exception_types = (ValueError,)
+
+    if visible_deprecation_warning is not None:
+        warnings.filterwarnings("error", category=visible_deprecation_warning)
+        exception_types = (visible_deprecation_warning, ValueError)  # type: ignore[assignment]
+
     try:
         arr = np.array(data)
-    except (np.VisibleDeprecationWarning, ValueError):
+    except exception_types:
         # In recent version of numpy, this warning should be raised when bad list provided.
         raise snowml_exceptions.SnowflakeMLException(
             error_code=error_codes.INVALID_DATA,
@@ -36,7 +42,10 @@ def convert_list_to_ndarray(data: list[Any]) -> npt.NDArray[Any]:
                 f"Unable to construct signature: Ragged nested or Unsupported list-like data {data} confronted."
             ),
         )
-    warnings.filterwarnings("default", category=np.VisibleDeprecationWarning)
+    finally:
+        if visible_deprecation_warning is not None:
+            warnings.filterwarnings("default", category=visible_deprecation_warning)
+
     if arr.dtype == object:
         # If not raised, then a array of object would be created.
         raise snowml_exceptions.SnowflakeMLException(