oafuncs 0.0.97.14__tar.gz → 0.0.97.15__tar.gz

{oafuncs-0.0.97.14/oafuncs.egg-info → oafuncs-0.0.97.15}/PKG-INFO

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

{oafuncs-0.0.97.14 → oafuncs-0.0.97.15}/oafuncs/_script/netcdf_merge.py

@@ -48,7 +48,7 @@ def merge_nc(file_list: Union[str, List[str]], var_name: Optional[Union[str, Lis
     # 初始化合并数据字典
     merged_data = {}
 
-    for i, file in pbar(enumerate(file_list),description="Reading files", color="green",total=len(file_list)):
+    for i, file in pbar(enumerate(file_list), description="Reading files", color="#f8bbd0", total=len(file_list)):
         with xr.open_dataset(file) as ds:
             for var in var_names:
                 data_var = ds[var]

oafuncs-0.0.97.15/oafuncs/_script/netcdf_modify.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+# coding=utf-8
+"""
+Author: Liu Kun && 16031215@qq.com
+Date: 2025-04-05 14:00:50
+LastEditors: Liu Kun && 16031215@qq.com
+LastEditTime: 2025-04-05 14:00:50
+FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\_script\\netcdf_modify.py
+Description:
+EditPlatform: vscode
+ComputerInfo: XPS 15 9510
+SystemInfo: Windows 11
+Python Version: 3.12
+"""
+
+import os
+
+import netCDF4 as nc
+import numpy as np
+from rich import print
+
+
+def _is_valid_netcdf_file(file_path):
+    """
+    Check if the file is a valid NetCDF file.
+    """
+    try:
+        with nc.Dataset(file_path, "r") as _:
+            pass
+        return True
+    except Exception:
+        return False
+
+
+def _modify_var(nc_file_path, variable_name, new_value):
+    """
+    Modify the value of a variable in a NetCDF file.
+    """
+    if not os.path.exists(nc_file_path):
+        raise FileNotFoundError(f"NetCDF file '{nc_file_path}' does not exist.")
+    if not _is_valid_netcdf_file(nc_file_path):
+        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.")
+    if not isinstance(new_value, np.ndarray):
+        raise TypeError("New value must be a numpy.ndarray.")
+
+    try:
+        with nc.Dataset(nc_file_path, "r+") as dataset:
+            if variable_name not in dataset.variables:
+                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}.")
+            variable[:] = new_value
+        print(f"[green]Successfully modified variable '{variable_name}' in '{nc_file_path}'.[/green]")
+        return True
+    except (FileNotFoundError, ValueError, TypeError) as e:
+        print(f"[red]Error:[/red] {e}")
+        return False
+    except Exception as e:
+        print(f"[red]Unexpected Error:[/red] Failed to modify variable '{variable_name}' in '{nc_file_path}'. [bold]Details:[/bold] {e}")
+        return False
+
+
+def _modify_attr(nc_file_path, variable_name, attribute_name, attribute_value):
+    """
+    Add or modify an attribute of a variable in a NetCDF file.
+    """
+    if not os.path.exists(nc_file_path):
+        raise FileNotFoundError(f"NetCDF file '{nc_file_path}' does not exist.")
+    if not _is_valid_netcdf_file(nc_file_path):
+        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.")
+    if not attribute_name:
+        raise ValueError("Attribute name cannot be empty or None.")
+
+    try:
+        with nc.Dataset(nc_file_path, "r+") as ds:
+            if variable_name not in ds.variables:
+                raise ValueError(f"Variable '{variable_name}' not found in the NetCDF file.")
+            variable = ds.variables[variable_name]
+            variable.setncattr(attribute_name, attribute_value)
+        print(f"[green]Successfully modified attribute '{attribute_name}' of variable '{variable_name}' in '{nc_file_path}'.[/green]")
+        return True
+    except (FileNotFoundError, ValueError) as e:
+        print(f"[red]Error:[/red] {e}")
+        return False
+    except Exception as e:
+        print(f"[red]Unexpected Error:[/red] Failed to modify attribute '{attribute_name}' of variable '{variable_name}' in file '{nc_file_path}'. [bold]Details:[/bold] {e}")
+        return False
+
+
+def modify_nc(nc_file, var_name, attr_name=None, new_value=None):
+    """
+    Modify the value of a variable or the value of an attribute in a NetCDF file.
+    """
+    try:
+        if attr_name is None:
+            return _modify_var(nc_file, var_name, new_value)
+        else:
+            return _modify_attr(nc_file, var_name, attr_name, new_value)
+    except Exception as e:
+        print(f"[red]Error:[/red] An error occurred while modifying '{var_name}' in '{nc_file}'. [bold]Details:[/bold] {e}")
+        return False

oafuncs-0.0.97.15/oafuncs/_script/netcdf_write.py

@@ -0,0 +1,125 @@
+import numpy as np
+import os
+import netCDF4 as nc
+import xarray as xr
+
+
+def _numpy_to_nc_type(numpy_type):
+    """将NumPy数据类型映射到NetCDF数据类型"""
+    numpy_to_nc = {
+        "float32": "f4",
+        "float64": "f8",
+        "int8": "i1",
+        "int16": "i2",
+        "int32": "i4",
+        "int64": "i8",
+        "uint8": "u1",
+        "uint16": "u2",
+        "uint32": "u4",
+        "uint64": "u8",
+    }
+    # 确保传入的是字符串类型，如果不是，则转换为字符串
+    numpy_type_str = str(numpy_type) if not isinstance(numpy_type, str) else numpy_type
+    return numpy_to_nc.get(numpy_type_str, "f4")  # 默认使用 'float32'
+
+
+def _calculate_scale_and_offset(data, n=16):
+    if not isinstance(data, np.ndarray):
+        raise ValueError("Input data must be a NumPy array.")
+
+    # 使用 nan_to_num 来避免 NaN 值对 min 和 max 的影响
+    data_min = np.nanmin(data)
+    data_max = np.nanmax(data)
+
+    if np.isnan(data_min) or np.isnan(data_max):
+        raise ValueError("Input data contains NaN values, which are not allowed.")
+
+    scale_factor = (data_max - data_min) / (2**n - 1)
+    add_offset = data_min + 2 ** (n - 1) * scale_factor
+
+    return scale_factor, add_offset
+
+
+def save_to_nc(file, data, varname=None, coords=None, mode="w", scale_offset_switch=True, compile_switch=True):
+    """
+    Description:
+        Write data to NetCDF file
+    Parameters:
+        file: str, file path
+        data: data
+        varname: str, variable name
+        coords: dict, coordinates, key is the dimension name, value is the coordinate data
+        mode: str, write mode, 'w' for write, 'a' for append
+        scale_offset_switch: bool, whether to use scale_factor and add_offset, default is True
+        compile_switch: bool, whether to use compression parameters, default is True
+    Example:
+        save(r'test.nc', data, 'u', {'time': np.linspace(0, 120, 100), 'lev': np.linspace(0, 120, 50)}, 'a')
+    """
+    # 设置压缩参数
+    kwargs = {"zlib": True, "complevel": 4} if compile_switch else {}
+
+    # 检查文件存在性并根据模式决定操作
+    if mode == "w" and os.path.exists(file):
+        os.remove(file)
+    elif mode == "a" and not os.path.exists(file):
+        mode = "w"
+
+    # 打开 NetCDF 文件
+    with nc.Dataset(file, mode, format="NETCDF4") as ncfile:
+        # 如果 data 是 DataArray 并且没有提供 varname 和 coords
+        if varname is None and coords is None and isinstance(data, xr.DataArray):
+            encoding = {}
+            for var in data.data_vars:
+                scale_factor, add_offset = _calculate_scale_and_offset(data[var].values)
+                encoding[var] = {
+                    "zlib": True,
+                    "complevel": 4,
+                    "dtype": "int16",
+                    "scale_factor": scale_factor,
+                    "add_offset": add_offset,
+                    "_FillValue": -32767,
+                }
+            data.to_netcdf(file, mode=mode, encoding=encoding)
+            return
+
+        # 添加坐标
+        for dim, coord_data in coords.items():
+            if dim in ncfile.dimensions:
+                if len(coord_data) != len(ncfile.dimensions[dim]):
+                    raise ValueError(f"Length of coordinate '{dim}' does not match the dimension length.")
+                else:
+                    ncfile.variables[dim][:] = np.array(coord_data)
+            else:
+                ncfile.createDimension(dim, len(coord_data))
+                var = ncfile.createVariable(dim, _numpy_to_nc_type(coord_data.dtype), (dim,), **kwargs)
+                var[:] = np.array(coord_data)
+
+                # 如果坐标数据有属性，则添加到 NetCDF 变量
+                if isinstance(coord_data, xr.DataArray) and coord_data.attrs:
+                    for attr_name, attr_value in coord_data.attrs.items():
+                        var.setncattr(attr_name, attr_value)
+
+        # 添加或更新变量
+        if varname in ncfile.variables:
+            if data.shape != ncfile.variables[varname].shape:
+                raise ValueError(f"Shape of data does not match the variable shape for '{varname}'.")
+            ncfile.variables[varname][:] = np.array(data)
+        else:
+            # 创建变量
+            dim_names = tuple(coords.keys())
+            if scale_offset_switch:
+                scale_factor, add_offset = _calculate_scale_and_offset(np.array(data))
+                dtype = "i2"
+                var = ncfile.createVariable(varname, dtype, dim_names, fill_value=-32767, **kwargs)
+                var.setncattr("scale_factor", scale_factor)
+                var.setncattr("add_offset", add_offset)
+            else:
+                dtype = _numpy_to_nc_type(data.dtype)
+                var = ncfile.createVariable(varname, dtype, dim_names, **kwargs)
+            var[:] = np.array(data)
+
+        # 添加属性
+        if isinstance(data, xr.DataArray) and data.attrs:
+            for key, value in data.attrs.items():
+                if key not in ["scale_factor", "add_offset", "_FillValue", "missing_value"] or not scale_offset_switch:
+                    var.setncattr(key, value)

oafuncs-0.0.97.15/oafuncs/oa_cmap.py

@@ -0,0 +1,162 @@
+from typing import List, Optional, Union
+
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import numpy as np
+from rich import print
+
+__all__ = ["show", "to_color", "create", "get"]
+
+
+# ** 将cmap用填色图可视化（官网摘抄函数）
+def show(colormaps: Union[str, mpl.colors.Colormap, List[Union[str, mpl.colors.Colormap]]]) -> None:
+    """
+    Description:
+        Helper function to plot data with associated colormap.
+    Parameters:
+        colormaps : list of colormaps, or a single colormap; can be a string or a colormap object.
+    Example:
+        cmap = ListedColormap(["darkorange", "gold", "lawngreen", "lightseagreen"])
+        show([cmap]); show("viridis"); show(["viridis", "cividis"])
+    """
+    if not isinstance(colormaps, list):
+        colormaps = [colormaps]
+    np.random.seed(19680801)
+    data = np.random.randn(30, 30)
+    n = len(colormaps)
+    fig, axs = plt.subplots(1, n, figsize=(n * 2 + 2, 3), constrained_layout=True, squeeze=False)
+    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)
+    plt.show()
+
+
+# ** 将cmap转为list，即多个颜色的列表
+def to_color(cmap_name: str, n: int = 256) -> List[tuple]:
+    """
+    Description:
+        Convert a colormap to a list of colors
+    Parameters:
+        cmap_name : str; the name of the colormap
+        n         : int, optional; the number of colors
+    Return:
+        out_colors : list of colors
+    Example:
+        out_colors = to_color('viridis', 256)
+    """
+    cmap = mpl.colormaps.get_cmap(cmap_name)
+    return [cmap(i) for i in np.linspace(0, 1, n)]
+
+
+# ** 自制cmap，多色，可带位置
+def create(color_list: Optional[List[Union[str, tuple]]] = None, rgb_file_path: Optional[str] = None, positions: Optional[List[float]] = None, under_color: Optional[Union[str, tuple]] = None, over_color: Optional[Union[str, tuple]] = None, delimiter: str = ",") -> mpl.colors.Colormap:
+    """
+    Description:
+        Create a custom colormap from a list of colors or an RGB txt document.
+    Parameters:
+        color_list  : list of colors (optional, required if rgb_file_path is None)
+        rgb_file_path : str, the path of txt file (optional, required if color_list is None)
+        positions   : list of positions (optional, for color_list)
+        under_color : color (optional)
+        over_color  : color (optional)
+        delimiter   : str, optional, default is ','; the delimiter of RGB values in txt file
+    Return:
+        cmap : colormap
+    Example:
+        cmap = create(color_list=['#C2B7F3','#B3BBF2','#B0CBF1','#ACDCF0','#A8EEED'])
+        cmap = create(color_list=['aliceblue','skyblue','deepskyblue'], positions=[0.0,0.5,1.0])
+        cmap = create(rgb_file_path='path/to/file.txt', delimiter=',')
+    """
+    if rgb_file_path:
+        with open(rgb_file_path) as fid:
+            data = fid.readlines()
+        n = len(data)
+        rgb = np.zeros((n, 3))
+        for i in np.arange(n):
+            rgb[i][0] = data[i].split(delimiter)[0]
+            rgb[i][1] = data[i].split(delimiter)[1]
+            rgb[i][2] = data[i].split(delimiter)[2]
+        max_rgb = np.max(rgb)
+        if max_rgb > 2:  # if the value is greater than 2, it is normalized to 0-1
+            rgb = rgb / 255.0
+        cmap_color = mpl.colors.ListedColormap(rgb, name="my_color")
+    elif color_list:
+        if positions is None:  # 自动分配比例
+            cmap_color = mpl.colors.LinearSegmentedColormap.from_list("mycmap", color_list)
+        else:  # 按提供比例分配
+            cmap_color = mpl.colors.LinearSegmentedColormap.from_list("mycmap", list(zip(positions, color_list)))
+    else:
+        raise ValueError("Either 'color_list' or 'rgb_file_path' must be provided.")
+
+    if under_color is not None:
+        cmap_color.set_under(under_color)
+    if over_color is not None:
+        cmap_color.set_over(over_color)
+    return cmap_color
+
+
+# ** 选择cmap
+def get(cmap_name: Optional[str] = None, query: bool = False) -> Optional[mpl.colors.Colormap]:
+    """
+    Description:
+        Choosing a colormap from the list of available colormaps or a custom colormap
+    Parameters:
+        cmap_name : str, optional; the name of the colormap
+        query     : bool, optional; whether to query the available colormap names
+    Return:
+        cmap : colormap
+    Example:
+        cmap = get('viridis')
+        cmap = get('diverging_1')
+        cmap = get('cool_1')
+        cmap = get('warm_1')
+        cmap = get('colorful_1')
+    """
+    my_cmap_dict = {
+        "diverging_1": create(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"]),
+        "cool_1": create(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC"]),
+        "warm_1": create(["#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"]),
+        "colorful_1": create(["#6d00db", "#9800cb", "#F2003C", "#ff4500", "#ff7f00", "#FE28A2", "#FFC0CB", "#DDA0DD", "#40E0D0", "#1a66f2", "#00f7fb", "#8fff88", "#E3FF00"]),
+    }
+
+    if query:
+        print("Available cmap names:")
+        print("-" * 20)
+        print("Defined by myself:")
+        print("\n".join(my_cmap_dict.keys()))
+        print("-" * 20)
+        print("Matplotlib built-in:")
+        print("\n".join(mpl.colormaps.keys()))
+        print("-" * 20)
+        return None
+
+    if cmap_name is None:
+        return None
+
+    if cmap_name in my_cmap_dict:
+        return my_cmap_dict[cmap_name]
+    else:
+        try:
+            return mpl.colormaps.get_cmap(cmap_name)
+        except ValueError:
+            print(f"Unknown cmap name: {cmap_name}\nNow return 'rainbow' as default.")
+            return mpl.colormaps.get_cmap("rainbow")  # 默认返回 'rainbow'
+
+
+if __name__ == "__main__":
+    # ** 测试自制cmap
+    colors = ["#C2B7F3", "#B3BBF2", "#B0CBF1", "#ACDCF0", "#A8EEED"]
+    nodes = [0.0, 0.2, 0.4, 0.6, 1.0]
+    c_map = create(colors, nodes)
+    show([c_map])
+
+    # ** 测试自制diverging型cmap
+    diverging_cmap = create(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"])
+    show([diverging_cmap])
+
+    # ** 测试根据RGB的txt文档制作色卡
+    file_path = "E:/python/colorbar/test.txt"
+    cmap_rgb = create(rgb_file_path=file_path)
+
+    # ** 测试将cmap转为list
+    out_colors = to_color("viridis", 256)

{oafuncs-0.0.97.14 → oafuncs-0.0.97.15}/oafuncs/oa_date.py

@@ -13,40 +13,39 @@ SystemInfo: Windows 11
 Python Version: 3.12
 """
 
-
-
 import calendar
 import datetime
+from typing import List, Optional
 
-__all__ = ["get_days_in_month", "generate_hour_list", "adjust_time", "timeit"]
+__all__ = ["month_days", "hour_range", "adjust_time", "timeit"]
 
 
-def get_days_in_month(year, month):
+def month_days(year: int, month: int) -> int:
     return calendar.monthrange(year, month)[1]
 
 
-def generate_hour_list(start_date, end_date, interval_hours=6):
+def hour_range(start: str, end: str, interval: int = 6) -> List[str]:
     """
     Generate a list of datetime strings with a specified interval in hours.
 
     Args:
-        start_date (str): Start date in the format "%Y%m%d%H".
-        end_date (str): End date in the format "%Y%m%d%H".
-        interval_hours (int): Interval in hours between each datetime.
+        start (str): Start date in the format "%Y%m%d%H".
+        end (str): End date in the format "%Y%m%d%H".
+        interval (int): Interval in hours between each datetime.
 
     Returns:
         list: List of datetime strings in the format "%Y%m%d%H".
     """
-    date_s = datetime.datetime.strptime(start_date, "%Y%m%d%H")
-    date_e = datetime.datetime.strptime(end_date, "%Y%m%d%H")
+    date_s = datetime.datetime.strptime(start, "%Y%m%d%H")
+    date_e = datetime.datetime.strptime(end, "%Y%m%d%H")
     date_list = []
     while date_s <= date_e:
         date_list.append(date_s.strftime("%Y%m%d%H"))
-        date_s += datetime.timedelta(hours=interval_hours)
+        date_s += datetime.timedelta(hours=interval)
     return date_list
 
 
-def adjust_time(initial_time, amount, time_unit="hours", output_format=None):
+def adjust_time(initial_time: str, amount: int, time_unit: str = "hours", output_format: Optional[str] = None) -> str:
     """
     Adjust a given initial time by adding a specified amount of time.
 
@@ -91,22 +90,37 @@ def adjust_time(initial_time, amount, time_unit="hours", output_format=None):
             default_format = "%Y%m%d"
         return time_obj.strftime(default_format)
 
+
 class timeit:
     """
     A decorator to measure the execution time of a function.
 
     Usage:
-        @timeit
+        @timeit(log=True, print_time=True)
         def my_function():
             # Function code here
+
+    Args:
+        log (bool): Whether to log the execution time to a file. Defaults to False.
+        print_time (bool): Whether to print the execution time to the console. Defaults to True.
     """
-    def __init__(self, func):
+
+    def __init__(self, func, log: bool = False, print_time: bool = True):
         self.func = func
+        self.log = log
+        self.print_time = print_time
 
     def __call__(self, *args, **kwargs):
         start_time = datetime.datetime.now()
         result = self.func(*args, **kwargs)
         end_time = datetime.datetime.now()
         elapsed_time = (end_time - start_time).total_seconds()
-        print(f"Function '{self.func.__name__}' executed in {elapsed_time:.2f} seconds.")
-        return result
+
+        if self.print_time:
+            print(f"Function '{self.func.__name__}' executed in {elapsed_time:.2f} seconds.")
+
+        if self.log:
+            with open("execution_time.log", "a") as log_file:
+                log_file.write(f"{datetime.datetime.now()} - Function '{self.func.__name__}' executed in {elapsed_time:.2f} seconds.\n")
+
+        return result

{oafuncs-0.0.97.14 → oafuncs-0.0.97.15}/oafuncs/oa_down/hycom_3hourly.py

@@ -40,7 +40,7 @@ from oafuncs.oa_nc import modify as modify_nc
 
 warnings.filterwarnings("ignore", category=RuntimeWarning, message="Engine '.*' loading failed:.*")
 
-__all__ = ["draw_time_range", "download", "how_to_use", "get_time_list"]
+__all__ = ["draw_time_range", "download"]
 
 
 def _get_initial_data():
@@ -278,7 +278,7 @@ def draw_time_range(pic_save_folder=None):
     plt.close()
 
 
-def get_time_list(time_s, time_e, delta, interval_type="hour"):
+def _get_time_list(time_s, time_e, delta, interval_type="hour"):
     """
     Description: get a list of time strings from time_s to time_e with a specified interval
     Args:
@@ -1029,7 +1029,7 @@ def _download_hourly_func(var, time_s, time_e, lon_min=0, lon_max=359.92, lat_mi
         _prepare_url_to_download(var, lon_min, lon_max, lat_min, lat_max, ymdh_time_s, None, depth, level, store_path, dataset_name, version_name, check)
     elif int(ymdh_time_s) < int(ymdh_time_e):
         print("Downloading a series of files...")
-        time_list = get_time_list(ymdh_time_s, ymdh_time_e, interval_hour, "hour")
+        time_list = _get_time_list(ymdh_time_s, ymdh_time_e, interval_hour, "hour")
         with Progress() as progress:
             task = progress.add_task(f"[cyan]{bar_desc}", total=len(time_list))
             if ftimes == 1:
@@ -1048,7 +1048,7 @@ def _download_hourly_func(var, time_s, time_e, lon_min=0, lon_max=359.92, lat_mi
                             _done_callback(feature, progress, task, len(time_list), counter_lock)
             else:
                 # new_time_list = get_time_list(ymdh_time_s, ymdh_time_e, 3 * ftimes, "hour")
-                new_time_list = get_time_list(ymdh_time_s, ymdh_time_e, interval_hour * ftimes, "hour")
+                new_time_list = _get_time_list(ymdh_time_s, ymdh_time_e, interval_hour * ftimes, "hour")
                 total_num = len(new_time_list)
                 if num_workers is None or num_workers <= 1:
                     # 串行方式
@@ -1248,55 +1248,6 @@ def download(var, time_s, time_e=None, lon_min=0, lon_max=359.92, lat_min=-80, l
     print("[bold #ecdbfe]=" * mark_len)
 
 
-def how_to_use():
-    print("""
-    # 1. Choose the dataset and version according to the time:
-    # 1.1 Use function to query
-    You can use the function check_time_in_dataset_and_version(time_input=20241101) to find the dataset and version  according to the time.
-    Then, you can see the dataset and version in the output.
-    # 1.2 Draw a picture to see
-    You can draw a picture to see the time range of each dataset and version.
-    Using the function draw_time_range(pic_save_folder=None) to draw the picture.
-
-    # 2. Get the base url according to the dataset, version, var and year:
-    # 2.1 Dataset and version were found in step 1
-    # 2.2 Var: u, v, temp, salt, ssh, u_b, v_b, temp_b, salt_b
-    # 2.3 Year: 1994-2024(current year)
-
-    # 3. Get the query_dict according to the var, lon_min, lon_max, lat_min, lat_max, depth, level_num, time_str_ymdh:
-    # 3.1 Var: u, v, temp, salt, ssh, u_b, v_b, temp_b, salt_b
-    # 3.2 Lon_min, lon_max, lat_min, lat_max: float
-    # 3.3 Depth: 0-5000m, if you wanna get single depth data, you can set the depth
-    # 3.4 Level_num: 1-40, if you wanna get single level data, you can set the level_num
-    # 3.5 Time_str_ymdh: '2024110112', the hour normally is 00, 03, 06, 09, 12, 15, 18, 21, besides 1 hourly data
-    # 3.6 Use the function to get the query_dict
-    # 3.7 Note: If you wanna get the full depth or full level data, you can needn't set the depth or level_num
-
-    # 4. Get the submit url according to the dataset, version, var, year, query_dict:
-    # 4.1 Use the function to get the submit url
-    # 4.2 You can use the submit url to download the data
-
-    # 5. Download the data according to the submit url:
-    # 5.1 Use the function to download the data
-    # 5.2 You can download the data of single time or a series of time
-    # 5.3 Note: If you wanna download a series of data, you can set the ymdh_time_s and ymdh_time_e different
-    # 5.4 Note: The time resolution is 3 hours
-
-    # 6. Direct download the data:
-    # 6.1 Use the function to direct download the data
-    # 6.2 You can set the dataset_name and version_name by yourself
-    # 6.3 Note: If you do not set the dataset_name and version_name, the dataset and version will be chosen according to the download_time
-    # 6.4 Note: If you set the dataset_name and version_name, please ensure the dataset_name and version_name are correct
-    # 6.5 Note: If you just set one of the dataset_name and version_name, both the dataset and version will be chosen according to the download_time
-
-    # 7. Simple use:
-    # 7.1 You can use the function: download(var, ymdh_time_s, ymdh_time_e, lon_min=0, lon_max=359.92, lat_min=-80, lat_max=90,  depth=None, level_num=None, store_path=None, dataset_name=None, version_name=None)
-    # 7.2 You can download the data of single time or a series of time
-    # 7.3 The parameters you must set are var, ymdh_time_s, ymdh_time_e
-    # 7.4 Example: download('u', '2024110112', '2024110212', lon_min=0, lon_max=359.92, lat_min=-80, lat_max=90,  depth=None, level_num=None, store_path=None, dataset_name=None, version_name=None)
-    """)
-
-
 if __name__ == "__main__":
     download_dict = {
         "water_u": {"simple_name": "u", "download": 1},