oafuncs 0.0.97.16__tar.gz → 0.0.97.17__tar.gz

{oafuncs-0.0.97.16/oafuncs.egg-info → oafuncs-0.0.97.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oafuncs
-Version: 0.0.97.16
+Version: 0.0.97.17
 Summary: Oceanic and Atmospheric Functions
 Home-page: https://github.com/Industry-Pays/OAFuncs
 Author: Kun Liu

{oafuncs-0.0.97.16 → oafuncs-0.0.97.17}/oafuncs/_script/netcdf_modify.py

@@ -42,8 +42,13 @@ def _modify_var(nc_file_path, variable_name, new_value):
         raise ValueError(f"File '{nc_file_path}' is not a valid NetCDF file.")
     if not variable_name:
         raise ValueError("Variable name cannot be empty or None.")
+
+    # 自动尝试将 new_value 转换为 numpy.ndarray
     if not isinstance(new_value, np.ndarray):
-        raise TypeError("New value must be a numpy.ndarray.")
+        try:
+            new_value = np.array(new_value)
+        except Exception:
+            raise TypeError("New value must be a numpy.ndarray or convertible to numpy.ndarray.")
 
     try:
         with nc.Dataset(nc_file_path, "r+") as dataset:
@@ -51,7 +56,10 @@ def _modify_var(nc_file_path, variable_name, new_value):
                 raise ValueError(f"Variable '{variable_name}' not found in the NetCDF file.")
             variable = dataset.variables[variable_name]
             if variable.shape != new_value.shape:
-                raise ValueError(f"Shape mismatch: Variable '{variable_name}' has shape {variable.shape}, but new value has shape {new_value.shape}.")
+                try:
+                    new_value = new_value.reshape(variable.shape)
+                except ValueError:
+                    raise ValueError(f"Shape mismatch: Variable '{variable_name}' has shape {variable.shape}, but new value has shape {new_value.shape}. Reshaping failed.")
             variable[:] = new_value
         print(f"[green]Successfully modified variable '{variable_name}' in '{nc_file_path}'.[/green]")
         return True

oafuncs-0.0.97.17/oafuncs/oa_cmap.py

@@ -0,0 +1,278 @@
+from typing import List, Optional, Union
+
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import numpy as np
+
+__all__ = ["show", "to_color", "create", "get"]
+
+
+# ** 将cmap用填色图可视化（官网摘抄函数）
+def show(colormaps: Union[str, mpl.colors.Colormap, List[Union[str, mpl.colors.Colormap]]]) -> None:
+    """Helper function to plot data with associated colormap.
+
+    This function creates a visualization of one or more colormaps by applying them
+    to randomly generated data in a pcolormesh plot.
+
+    Parameters
+    ----------
+    colormaps : Union[str, mpl.colors.Colormap, List[Union[str, mpl.colors.Colormap]]]
+        List of colormaps, or a single colormap; can be a string name or a colormap object.
+
+    Returns
+    -------
+    None
+        This function displays the plot but does not return any value.
+
+    Examples
+    --------
+    >>> cmap = matplotlib.colors.ListedColormap(["darkorange", "gold", "lawngreen", "lightseagreen"])
+    >>> show([cmap])
+    >>> show("viridis")
+    >>> show(["viridis", "cividis"])
+    """
+    # Convert single colormap to list for uniform processing
+    if not isinstance(colormaps, list):
+        colormaps = [colormaps]
+
+    # Create a formatted list of colormap names for display
+    cmap_names = []
+    for cmap in colormaps:
+        if isinstance(cmap, str):
+            cmap_names.append(cmap)
+        elif hasattr(cmap, "name"):
+            cmap_names.append(cmap.name)
+        else:
+            cmap_names.append("unnamed_colormap")
+
+    print(f"Visualizing {len(colormaps)} colormap(s): {', '.join(cmap_names)}")
+
+    # Generate random data with fixed seed for reproducibility
+    np.random.seed(19680801)
+    data = np.random.randn(30, 30)
+
+    # Create subplots based on number of colormaps
+    n = len(colormaps)
+    fig, axs = plt.subplots(1, n, figsize=(n * 2 + 2, 3), constrained_layout=True, squeeze=False)
+
+    # Plot each colormap
+    for ax, cmap in zip(axs.flat, colormaps):
+        psm = ax.pcolormesh(data, cmap=cmap, rasterized=True, vmin=-4, vmax=4)
+        fig.colorbar(psm, ax=ax)
+
+        # Set title if colormap has a name
+        if isinstance(cmap, str):
+            ax.set_title(cmap)
+        elif hasattr(cmap, "name") and cmap.name:
+            ax.set_title(cmap.name)
+
+    print("Displaying colormap visualization...")
+    plt.show()
+
+
+# ** 将cmap转为list，即多个颜色的列表
+def to_color(colormap_name: str, num_colors: int = 256) -> List[tuple]:
+    """Convert a colormap to a list of colors.
+
+    Args:
+        colormap_name (str): The name of the colormap.
+        num_colors (int, optional): The number of colors. Defaults to 256.
+
+    Returns:
+        List[tuple]: List of RGBA colors.
+
+    Raises:
+        ValueError: If the colormap name is not recognized.
+
+    Examples:
+        >>> out_colors = to_color('viridis', 256)
+    """
+    try:
+        cmap = mpl.colormaps.get_cmap(colormap_name)
+        return [cmap(i) for i in np.linspace(0, 1, num_colors)]
+    except (ValueError, TypeError):
+        error_msg = f"Invalid colormap name: {colormap_name}"
+        print(error_msg)
+        raise ValueError(error_msg)
+
+
+# ** 自制cmap，多色，可带位置
+def create(color_list: Optional[List[Union[str, tuple]]] = None, rgb_file: Optional[str] = None, color_positions: Optional[List[float]] = None, below_range_color: Optional[Union[str, tuple]] = None, above_range_color: Optional[Union[str, tuple]] = None, value_delimiter: str = ",") -> mpl.colors.Colormap:
+    """Create a custom colormap from a list of colors or an RGB txt document.
+
+    Args:
+        color_list (Optional[List[Union[str, tuple]]]): List of colors. Required if rgb_file is None.
+        rgb_file (Optional[str]): The path of txt file. Required if color_list is None.
+        color_positions (Optional[List[float]]): List of positions for color_list. Must have same length as color_list.
+        below_range_color (Optional[Union[str, tuple]]): Color for values below the colormap range.
+        above_range_color (Optional[Union[str, tuple]]): Color for values above the colormap range.
+        value_delimiter (str, optional): The delimiter of RGB values in txt file. Defaults to ",".
+
+    Returns:
+        mpl.colors.Colormap: Created colormap.
+
+    Raises:
+        ValueError: If neither color_list nor rgb_file is provided.
+        ValueError: If color_positions is provided but has different length than color_list.
+        FileNotFoundError: If rgb_file does not exist.
+        ValueError: If the RGB file format is invalid.
+
+    Examples:
+        >>> cmap = create(color_list=['#C2B7F3','#B3BBF2','#B0CBF1','#ACDCF0','#A8EEED'])
+        >>> cmap = create(color_list=['aliceblue','skyblue','deepskyblue'], color_positions=[0.0,0.5,1.0])
+        >>> cmap = create(rgb_file='path/to/file.txt', value_delimiter=',')
+    """
+    # Input validation
+    if rgb_file is None and color_list is None:
+        error_msg = "Either 'color_list' or 'rgb_file' must be provided."
+        print(error_msg)
+        raise ValueError(error_msg)
+
+    if color_positions is not None and color_list is not None:
+        if len(color_positions) != len(color_list):
+            error_msg = f"'color_positions' must have the same length as 'color_list' (positions: {len(color_positions)}, colors: {len(color_list)})"
+            print(error_msg)
+            raise ValueError(error_msg)
+        if not all(0 <= pos <= 1 for pos in color_positions):
+            error_msg = "All position values must be between 0 and 1"
+            print(error_msg)
+            raise ValueError(error_msg)
+        if color_positions != sorted(color_positions):
+            error_msg = f"Position values must be in ascending order: {color_positions}"
+            print(error_msg)
+            raise ValueError(error_msg)
+
+    if rgb_file:
+        try:
+            print(f"Reading RGB data from {rgb_file}...")
+
+            with open(rgb_file) as fid:
+                data = [line.strip() for line in fid if line.strip() and not line.strip().startswith("#")]
+
+            if not data:
+                error_msg = f"RGB file is empty or contains only comments: {rgb_file}"
+                print(error_msg)
+                raise ValueError(error_msg)
+
+            n = len(data)
+            rgb = np.zeros((n, 3))
+
+            for i in np.arange(n):
+                try:
+                    parts = data[i].split(value_delimiter)
+                    if len(parts) < 3:
+                        error_msg = f"Line {i + 1}: Expected at least 3 values, got {len(parts)}"
+                        print(error_msg)
+                        raise ValueError(error_msg)
+
+                    rgb[i][0] = float(parts[0])
+                    rgb[i][1] = float(parts[1])
+                    rgb[i][2] = float(parts[2])
+                except (ValueError, IndexError) as e:
+                    error_msg = f"Error parsing RGB values at line {i + 1}: {e}"
+                    print(error_msg)
+                    raise ValueError(error_msg)
+
+            max_rgb = np.max(rgb)
+            # Normalize RGB values if they are in 0-255 range
+            if max_rgb > 2:
+                rgb = rgb / 255.0
+            cmap_color = mpl.colors.ListedColormap(rgb, name="my_color")
+            print(f"Successfully created colormap from {rgb_file}")
+        except FileNotFoundError:
+            error_msg = f"RGB file not found: {rgb_file}"
+            print(error_msg)
+            raise FileNotFoundError(error_msg)
+    else:
+        # Create colormap from color list
+        if color_positions is None:
+            cmap_color = mpl.colors.LinearSegmentedColormap.from_list("mycmap", color_list)
+        else:
+            cmap_color = mpl.colors.LinearSegmentedColormap.from_list("mycmap", list(zip(color_positions, color_list)))
+        print(f"Successfully created colormap from {len(color_list)} colors")
+
+    # Set below/above range colors if provided
+    if below_range_color is not None:
+        cmap_color.set_under(below_range_color)
+        print(f"Set below-range color to {below_range_color}")
+    if above_range_color is not None:
+        cmap_color.set_over(above_range_color)
+        print(f"Set above-range color to {above_range_color}")
+
+    return cmap_color
+
+
+# ** 选择cmap
+def get(colormap_name: Optional[str] = None, show_available: bool = False) -> Optional[mpl.colors.Colormap]:
+    """Choose a colormap from the list of available colormaps or a custom colormap.
+
+    Args:
+        colormap_name (Optional[str], optional): The name of the colormap. Defaults to None.
+        show_available (bool, optional): Whether to query the available colormap names. Defaults to False.
+
+    Returns:
+        Optional[mpl.colors.Colormap]: Selected colormap or None if show_available is True or colormap_name is None.
+
+    Examples:
+        >>> cmap = get('viridis')
+        >>> cmap = get('diverging_1')
+        >>> cmap = get('cool_1')
+        >>> cmap = get('warm_1')
+        >>> cmap = get('colorful_1')
+    """
+    my_cmap_dict = {
+        "diverging_1": ["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"],
+        "cool_1": ["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC"],
+        "warm_1": ["#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"],
+        "colorful_1": ["#6d00db", "#9800cb", "#F2003C", "#ff4500", "#ff7f00", "#FE28A2", "#FFC0CB", "#DDA0DD", "#40E0D0", "#1a66f2", "#00f7fb", "#8fff88", "#E3FF00"],
+    }
+
+    if show_available:
+        print("Available cmap names:")
+        print("-" * 20)
+        print("Defined by myself:")
+        for name in my_cmap_dict.keys():
+            print(f"  • {name}")
+        print("-" * 20)
+        print("Matplotlib built-in:")
+        # 将Matplotlib内置cmap分批次打印，每行5个
+        built_in_cmaps = list(mpl.colormaps.keys())
+        for i in range(0, len(built_in_cmaps), 5):
+            print("  • " + ", ".join(built_in_cmaps[i : i + 5]))
+        print("-" * 20)
+        return None
+
+    if colormap_name is None:
+        return None
+
+    if colormap_name in my_cmap_dict:
+        print(f"Using custom colormap: {colormap_name}")
+        return create(my_cmap_dict[colormap_name])
+    else:
+        try:
+            cmap = mpl.colormaps.get_cmap(colormap_name)
+            print(f"Using matplotlib colormap: {colormap_name}")
+            return cmap
+        except ValueError:
+            print(f"Warning: Unknown cmap name: {colormap_name}")
+            print("Using rainbow as default.")
+            return mpl.colormaps.get_cmap("rainbow")  # 默认返回 'rainbow'
+
+
+if __name__ == "__main__":
+    # ** 测试自制cmap
+    colors = ["#C2B7F3", "#B3BBF2", "#B0CBF1", "#ACDCF0", "#A8EEED"]
+    color_nodes = [0.0, 0.2, 0.4, 0.6, 1.0]
+    custom_cmap = create(colors, color_nodes)
+    show([custom_cmap])
+
+    # ** 测试自制diverging型cmap
+    diverging_cmap = create(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"])
+    show([diverging_cmap])
+
+    # ** 测试根据RGB的txt文档制作色卡
+    rgb_file_path = "E:/python/colorbar/test.txt"
+    cmap_from_rgb = create(rgb_file=rgb_file_path)
+
+    # ** 测试将cmap转为list
+    viridis_colors = to_color("viridis", 256)

oafuncs-0.0.97.17/oafuncs/oa_data.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python
+# coding=utf-8
+"""
+Author: Liu Kun && 16031215@qq.com
+Date: 2024-09-17 17:12:47
+LastEditors: Liu Kun && 16031215@qq.com
+LastEditTime: 2024-12-13 19:11:08
+FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\oa_data.py
+Description:
+EditPlatform: vscode
+ComputerInfo: XPS 15 9510
+SystemInfo: Windows 11
+Python Version: 3.11
+"""
+
+import itertools
+import multiprocessing as mp
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, List, Union
+
+import numpy as np
+import salem
+import xarray as xr
+from rich import print
+from scipy.interpolate import griddata, interp1d
+
+__all__ = ["interp_along_dim", "interp_2d", "ensure_list", "mask_shapefile"]
+
+
+def ensure_list(input_value: Any) -> List[str]:
+    """
+    Ensure the input is converted into a list.
+
+    Args:
+        input_value (Any): The input which can be a list, a string, or any other type.
+
+    Returns:
+        List[str]: A list containing the input or the string representation of the input.
+    """
+    if isinstance(input_value, list):
+        return input_value
+    elif isinstance(input_value, str):
+        return [input_value]
+    else:
+        return [str(input_value)]
+
+
+def interp_along_dim(
+    target_coordinates: np.ndarray,
+    source_coordinates: Union[np.ndarray, List[float]],
+    source_data: np.ndarray,
+    interpolation_axis: int = -1,
+    interpolation_method: str = "linear",
+    extrapolation_method: str = "linear",
+) -> np.ndarray:
+    """
+    Perform interpolation and extrapolation along a specified dimension.
+
+    Args:
+        target_coordinates (np.ndarray): 1D array of target coordinate points.
+        source_coordinates (Union[np.ndarray, List[float]]): Source coordinate points (1D or ND array).
+        source_data (np.ndarray): Source data array to interpolate.
+        interpolation_axis (int, optional): Axis to perform interpolation on. Defaults to -1.
+        interpolation_method (str, optional): Interpolation method. Defaults to "linear".
+        extrapolation_method (str, optional): Extrapolation method. Defaults to "linear".
+
+    Returns:
+        np.ndarray: Interpolated data array.
+
+    Raises:
+        ValueError: If input dimensions or shapes are invalid.
+
+    Examples:
+        >>> target_coordinates = np.array([1, 2, 3])
+        >>> source_coordinates = np.array([0, 1, 2, 3])
+        >>> source_data = np.array([10, 20, 30, 40])
+        >>> result = interp_along_dim(target_coordinates, source_coordinates, source_data)
+        >>> print(result)  # Expected output: [20.0, 30.0]
+    """
+    target_coordinates = np.asarray(target_coordinates)
+    if target_coordinates.ndim != 1:
+        raise ValueError("[red]target_coordinates must be a 1D array.[/red]")
+
+    source_coordinates = np.asarray(source_coordinates)
+    source_data = np.asarray(source_data)
+
+    if source_data.ndim == 1 and source_coordinates.ndim == 1:
+        if len(source_coordinates) != len(source_data):
+            raise ValueError("[red]For 1D data, source_coordinates and source_data must have the same length.[/red]")
+
+        interpolator = interp1d(source_coordinates, source_data, kind=interpolation_method, fill_value="extrapolate", bounds_error=False)
+        return interpolator(target_coordinates)
+
+    if source_coordinates.ndim == 1:
+        shape = [1] * source_data.ndim
+        shape[interpolation_axis] = source_coordinates.shape[0]
+        source_coordinates = np.reshape(source_coordinates, shape)
+        source_coordinates = np.broadcast_to(source_coordinates, source_data.shape)
+    elif source_coordinates.shape != source_data.shape:
+        raise ValueError("[red]source_coordinates and source_data must have the same shape.[/red]")
+
+    def apply_interp_extrap(arr: np.ndarray) -> np.ndarray:
+        xp = np.moveaxis(source_coordinates, interpolation_axis, 0)
+        xp = xp[:, 0] if xp.ndim > 1 else xp
+        arr = np.moveaxis(arr, interpolation_axis, 0)
+        interpolator = interp1d(xp, arr, kind=interpolation_method, fill_value="extrapolate", bounds_error=False)
+        interpolated = interpolator(target_coordinates)
+        if extrapolation_method != interpolation_method:
+            mask_extrap = (target_coordinates < xp.min()) | (target_coordinates > xp.max())
+            if np.any(mask_extrap):
+                extrap_interpolator = interp1d(xp, arr, kind=extrapolation_method, fill_value="extrapolate", bounds_error=False)
+                interpolated[mask_extrap] = extrap_interpolator(target_coordinates[mask_extrap])
+        return np.moveaxis(interpolated, 0, interpolation_axis)
+
+    return np.apply_along_axis(apply_interp_extrap, interpolation_axis, source_data)
+
+
+def interp_2d(
+    target_x_coordinates: Union[np.ndarray, List[float]],
+    target_y_coordinates: Union[np.ndarray, List[float]],
+    source_x_coordinates: Union[np.ndarray, List[float]],
+    source_y_coordinates: Union[np.ndarray, List[float]],
+    source_data: np.ndarray,
+    interpolation_method: str = "linear",
+    use_parallel: bool = True,
+) -> np.ndarray:
+    """
+    Perform 2D interpolation on the last two dimensions of a multi-dimensional array.
+
+    Args:
+        target_x_coordinates (Union[np.ndarray, List[float]]): Target grid's x-coordinates.
+        target_y_coordinates (Union[np.ndarray, List[float]]): Target grid's y-coordinates.
+        source_x_coordinates (Union[np.ndarray, List[float]]): Original grid's x-coordinates.
+        source_y_coordinates (Union[np.ndarray, List[float]]): Original grid's y-coordinates.
+        source_data (np.ndarray): Multi-dimensional array with the last two dimensions as spatial.
+        interpolation_method (str, optional): Interpolation method. Defaults to "linear".
+        use_parallel (bool, optional): Enable parallel processing. Defaults to True.
+
+    Returns:
+        np.ndarray: Interpolated data array.
+
+    Raises:
+        ValueError: If input shapes are invalid.
+
+    Examples:
+        >>> target_x_coordinates = np.array([1, 2, 3])
+        >>> target_y_coordinates = np.array([4, 5, 6])
+        >>> source_x_coordinates = np.array([7, 8, 9])
+        >>> source_y_coordinates = np.array([10, 11, 12])
+        >>> source_data = np.random.rand(3, 3)
+        >>> result = interp_2d(target_x_coordinates, target_y_coordinates, source_x_coordinates, source_y_coordinates, source_data)
+        >>> print(result.shape)  # Expected output: (3, 3)
+    """
+
+    def interp_single(data_slice: np.ndarray, target_points: np.ndarray, origin_points: np.ndarray, method: str) -> np.ndarray:
+        return griddata(origin_points, data_slice.ravel(), target_points, method=method).reshape(target_y_coordinates.shape)
+
+    if len(target_y_coordinates.shape) == 1:
+        target_x_coordinates, target_y_coordinates = np.meshgrid(target_x_coordinates, target_y_coordinates)
+    if len(source_y_coordinates.shape) == 1:
+        source_x_coordinates, source_y_coordinates = np.meshgrid(source_x_coordinates, source_y_coordinates)
+
+    if source_x_coordinates.shape != source_data.shape[-2:] or source_y_coordinates.shape != source_data.shape[-2:]:
+        raise ValueError("[red]Shape of source_data does not match shape of source_x_coordinates or source_y_coordinates.[/red]")
+
+    target_points = np.column_stack((np.array(target_y_coordinates).ravel(), np.array(target_x_coordinates).ravel()))
+    origin_points = np.column_stack((np.array(source_y_coordinates).ravel(), np.array(source_x_coordinates).ravel()))
+
+    if use_parallel:
+        with ThreadPoolExecutor(max_workers=mp.cpu_count() - 2) as executor:
+            if len(source_data.shape) == 2:
+                interpolated_data = list(executor.map(interp_single, [source_data], [target_points], [origin_points], [interpolation_method]))
+            elif len(source_data.shape) == 3:
+                interpolated_data = list(executor.map(interp_single, [source_data[i] for i in range(source_data.shape[0])], [target_points] * source_data.shape[0], [origin_points] * source_data.shape[0], [interpolation_method] * source_data.shape[0]))
+            elif len(source_data.shape) == 4:
+                index_combinations = list(itertools.product(range(source_data.shape[0]), range(source_data.shape[1])))
+                interpolated_data = list(executor.map(interp_single, [source_data[i, j] for i, j in index_combinations], [target_points] * len(index_combinations), [origin_points] * len(index_combinations), [interpolation_method] * len(index_combinations)))
+                interpolated_data = np.array(interpolated_data).reshape(source_data.shape[0], source_data.shape[1], *target_y_coordinates.shape)
+    else:
+        if len(source_data.shape) == 2:
+            interpolated_data = interp_single(source_data, target_points, origin_points, interpolation_method)
+        elif len(source_data.shape) == 3:
+            interpolated_data = np.stack([interp_single(source_data[i], target_points, origin_points, interpolation_method) for i in range(source_data.shape[0])])
+        elif len(source_data.shape) == 4:
+            interpolated_data = np.stack([np.stack([interp_single(source_data[i, j], target_points, origin_points, interpolation_method) for j in range(source_data.shape[1])]) for i in range(source_data.shape[0])])
+
+    return np.squeeze(np.array(interpolated_data))
+
+
+def mask_shapefile(
+    data_array: np.ndarray,
+    longitudes: np.ndarray,
+    latitudes: np.ndarray,
+    shapefile_path: str,
+) -> Union[xr.DataArray, None]:
+    """
+    Mask a 2D data array using a shapefile.
+
+    Args:
+        data_array (np.ndarray): 2D array of data to be masked.
+        longitudes (np.ndarray): 1D array of longitudes.
+        latitudes (np.ndarray): 1D array of latitudes.
+        shapefile_path (str): Path to the shapefile used for masking.
+
+    Returns:
+        Union[xr.DataArray, None]: Masked xarray DataArray or None if an error occurs.
+
+    Raises:
+        FileNotFoundError: If the shapefile does not exist.
+        ValueError: If the data dimensions do not match the coordinates.
+
+    Examples:
+        >>> data_array = np.random.rand(10, 10)
+        >>> longitudes = np.linspace(-180, 180, 10)
+        >>> latitudes = np.linspace(-90, 90, 10)
+        >>> shapefile_path = "path/to/shapefile.shp"
+        >>> masked_data = mask_shapefile(data_array, longitudes, latitudes, shapefile_path)
+        >>> print(masked_data)  # Expected output: Masked DataArray
+
+    """
+    try:
+        shp_f = salem.read_shapefile(shapefile_path)
+        data_da = xr.DataArray(data_array, coords=[("latitude", latitudes), ("longitude", longitudes)])
+        masked_data = data_da.salem.roi(shape=shp_f)
+        return masked_data
+    except Exception as e:
+        print(f"[red]An error occurred: {e}[/red]")
+        return None
+
+
+if __name__ == "__main__":
+    pass