oafuncs 0.0.98.20__py3-none-any.whl → 0.0.98.22__py3-none-any.whl

oafuncs/_script/netcdf_merge.py

@@ -1,7 +1,7 @@
 import logging
 import os
 from typing import List, Optional, Union
-import numpy as np
+
 import xarray as xr
 
 from oafuncs import pbar
@@ -25,7 +25,6 @@ def merge_nc(file_list: Union[str, List[str]], var_name: Optional[Union[str, Lis
         merge(file_list, var_name=['u', 'v'], dim_name='time', target_filename='merged.nc')
         merge(file_list, var_name=None, dim_name='time', target_filename='merged.nc')
     """
-    from oafuncs._script.netcdf_write import save_to_nc
 
     if target_filename is None:
         target_filename = "merged.nc"
@@ -52,48 +51,78 @@ 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", total=len(file_list)):
+    for i, file in pbar(enumerate(file_list), "Reading files", total=len(file_list)):
         with xr.open_dataset(file) as ds:
             for var in var_names:
                 data_var = ds[var]
                 if dim_name in data_var.dims:
                     merged_data.setdefault(var, []).append(data_var)
                 elif var not in merged_data:
-                    # 区分更细致的类型，不仅是时间型和非时间型
-                    if data_var.dtype.kind == "M":  # datetime64类型
-                        merged_data[var] = data_var  # 时间类型在save_to_nc处理
-                    elif data_var.dtype.kind in ["f", "i", "u"]:  # 数值类型
-                        # 对数值型变量用-32767填充NaN，而不是0
-                        merged_data[var] = data_var.fillna(-32767)
-                    else:  # 字符串或其他类型
-                        merged_data[var] = data_var  # 非数值类型保持原样
-
-    for var in pbar(merged_data, description="Merging variables"):
+                    # 只负责合并，不做NaN填充，统一交由 netcdf_write.py 处理
+                    merged_data[var] = data_var
+
+    # 记录变量的填充值和缺失值信息，确保不会丢失
+    fill_values = {}
+    missing_values = {}
+    for var_name, var_data in merged_data.items():
+        if isinstance(var_data, list) and var_data:
+            # 如果是要合并的变量，检查第一个元素的属性
+            attrs = var_data[0].attrs
+            if "_FillValue" in attrs:
+                fill_values[var_name] = attrs["_FillValue"]
+            if "missing_value" in attrs:
+                missing_values[var_name] = attrs["missing_value"]
+        else:
+            # 如果是单个变量，直接检查属性
+            attrs = var_data.attrs if hasattr(var_data, "attrs") else {}
+            if "_FillValue" in attrs:
+                fill_values[var_name] = attrs["_FillValue"]
+            if "missing_value" in attrs:
+                missing_values[var_name] = attrs["missing_value"]
+
+    for var in pbar(merged_data, "Merging variables"):
         if isinstance(merged_data[var], list):
-            # 区分更细致的类型处理
-            if merged_data[var][0].dtype.kind == "M":  # datetime64类型
-                merged_data[var] = xr.concat(merged_data[var], dim=dim_name)
-            elif merged_data[var][0].dtype.kind in ["f", "i", "u"]:  # 数值类型
-                # 使用-32767填充NaN，而不是0
-                merged_data[var] = xr.concat(merged_data[var], dim=dim_name).fillna(-32767)
-            else:  # 字符串或其他类型
-                merged_data[var] = xr.concat(merged_data[var], dim=dim_name)
-
-    # 在构建最终数据集前，再次检查确保所有数值型变量没有NaN
+            # 使用 coords='minimal' 替代默认值，并移除可能冲突的 compat='override'
+            merged_data[var] = xr.concat(merged_data[var], dim=dim_name, coords="minimal")
+            # 恢复原始填充值和缺失值属性
+            if var in fill_values:
+                merged_data[var].attrs["_FillValue"] = fill_values[var]
+            if var in missing_values:
+                merged_data[var].attrs["missing_value"] = missing_values[var]
+
+    # 合并后构建 Dataset，此时 merged_data 只包含数据变量，不包含坐标变量
     merged_ds = xr.Dataset(merged_data)
-    for var_name in merged_ds.data_vars:
-        var = merged_ds[var_name]
-        if var.dtype.kind in ["f", "i", "u"]:
-            if np.isnan(var.values).any():
-                logging.warning(f"变量 {var_name} 在合并后仍包含NaN值，将替换为-32767")
-                merged_ds[var_name] = var.fillna(-32767)
+
+    # 自动补充坐标变量（如 time、lat、lon 等），以第一个文件为准
+    with xr.open_dataset(file_list[0]) as ds0:
+        for coord in ds0.coords:
+            # 保证坐标变量不会被覆盖，且数据类型和属性保持一致
+            if coord not in merged_ds.coords:
+                merged_ds = merged_ds.assign_coords({coord: ds0[coord]})
+
+    """ # 修改合并维度验证逻辑，更合理地检查所有文件维度的兼容性
+    if dim_name in merged_ds.coords and len(file_list) > 1:
+        logging.info(f"检查合并维度 {dim_name} 的有效性...")
+
+        # 收集所有文件的该维度值
+        all_dim_values = []
+        for file in file_list:
+            with xr.open_dataset(file) as ds:
+                if dim_name in ds.coords:
+                    all_dim_values.append(ds[dim_name].values)
+
+        # 只有当有两个或更多不同值集合时才警告
+        unique_values_count = len({tuple(vals.tolist()) if hasattr(vals, "tolist") else tuple(vals) for vals in all_dim_values})
+        if unique_values_count > 1:
+            logging.warning(f"检测到 {unique_values_count} 种不同的 {dim_name} 坐标值集合，合并可能导致数据重新排列")
+        else:
+            logging.info(f"所有文件的 {dim_name} 坐标值完全一致，合并将保持原始顺序") """
 
     if os.path.exists(target_filename):
-        # print("Warning: The target file already exists. Removing it ...")
         logging.warning("The target file already exists. Removing it ...")
         os.remove(target_filename)
 
-    save_to_nc(target_filename, merged_ds)
+    merged_ds.to_netcdf(target_filename, mode="w")
 
 
 # Example usage

oafuncs/_script/netcdf_write.py

@@ -8,7 +8,8 @@ import xarray as xr
 warnings.filterwarnings("ignore", category=RuntimeWarning)
 
 
-def _nan_to_fillvalue(ncfile):
+
+def _nan_to_fillvalue(ncfile,set_fill_value):
     """
     将 NetCDF 文件中所有变量的 NaN 和掩码值替换为其 _FillValue 属性（若无则自动添加 _FillValue=-32767 并替换）。
     同时处理掩码数组中的无效值。
@@ -27,8 +28,10 @@ def _nan_to_fillvalue(ncfile):
             # 确定填充值
             if "_FillValue" in var.ncattrs():
                 fill_value = var.getncattr("_FillValue")
+            elif hasattr(var, "missing_value"):
+                fill_value = var.getncattr("missing_value")
             else:
-                fill_value = -32767
+                fill_value = set_fill_value
                 try:
                     var.setncattr("_FillValue", fill_value)
                 except Exception:
@@ -39,11 +42,10 @@ def _nan_to_fillvalue(ncfile):
             if hasattr(arr, "mask"):
                 # 如果是掩码数组，将掩码位置的值设为 fill_value
                 if np.any(arr.mask):
-                    # 转换为普通数组，掩码位置填入 fill_value
-                    arr = np.ma.filled(arr, fill_value=fill_value)
+                    arr = np.where(arr.mask, fill_value, arr.data if hasattr(arr, "data") else arr)
 
-            # 处理剩余NaN值
-            if np.any(np.isnan(arr)):
+            # 处理剩余 NaN 和无穷值
+            if arr.dtype.kind in ["f", "i", "u"] and np.any(~np.isfinite(arr)):
                 arr = np.nan_to_num(arr, nan=fill_value, posinf=fill_value, neginf=fill_value)
 
             # 写回变量
@@ -68,60 +70,93 @@ def _numpy_to_nc_type(numpy_type):
     return numpy_to_nc.get(numpy_type_str, "f4")
 
 
-def _calculate_scale_and_offset(data, n=16):
+def _calculate_scale_and_offset(data, dtype="int32"):
     """
-    计算数值型数据的 scale_factor 与 add_offset，
-    将数据映射到 [0, 2**n - 1] 的范围。
-    同时处理数据中的 NaN 值。
+    只对有效数据（非NaN、非填充值、非自定义缺失值）计算scale_factor和add_offset。
+    使用 int32 类型，n=32
     """
     if not isinstance(data, np.ndarray):
         raise ValueError("Input data must be a NumPy array.")
+    
+    if dtype == "int32":
+        n = 32
+        fill_value = np.iinfo(np.int32).min  # -2147483648
+    elif dtype == "int16":
+        n = 16
+        fill_value = np.iinfo(np.int16).min  # -32768
+    else:
+        raise ValueError("Unsupported dtype. Supported types are 'int16' and 'int32'.")
 
-    # 先处理数据中的 NaN 和无穷值
-    clean_data = np.nan_to_num(data, nan=-32767, posinf=np.finfo(float).max, neginf=np.finfo(float).min)
+    # 有效掩码：非NaN、非inf、非fill_value
+    valid_mask = np.isfinite(data) & (data != fill_value)
+    if hasattr(data, "mask") and np.ma.is_masked(data):
+        valid_mask &= ~data.mask
 
-    # 计算有效值的最小最大值（排除填充值）
-    valid_mask = clean_data != -32767
     if np.any(valid_mask):
-        data_min = np.min(clean_data[valid_mask])
-        data_max = np.max(clean_data[valid_mask])
+        data_min = np.min(data[valid_mask])-1
+        data_max = np.max(data[valid_mask])+1
     else:
-        # 全都是填充值的情况，使用默认范围
         data_min, data_max = 0, 1
 
+    # 防止scale为0，且保证scale/offset不会影响缺省值
     if data_max == data_min:
         scale_factor = 1.0
         add_offset = data_min
     else:
-        scale_factor = (data_max - data_min) / (2**n - 1)
-        add_offset = data_min + 2 ** (n - 1) * scale_factor
+        scale_factor = (data_max - data_min) / (2**n - 2)
+        add_offset = (data_max + data_min) / 2.0
     return scale_factor, add_offset
 
 
-def _data_to_scale_offset(data, scale, offset):
+def _data_to_scale_offset(data, scale, offset, dtype='int32'):
     """
-    将数据转换为 scale_factor 和 add_offset 的形式。
-    此处同时替换 NaN、正无穷和负无穷为填充值 -32767，
-    以确保转换后的数据可安全转为 int16。
+    只对有效数据做缩放，NaN/inf/填充值直接赋为fill_value。
+    掩码区域的值会被保留并进行缩放，除非掩码本身标记为无效。
+    使用 int32 类型
     """
     if not isinstance(data, np.ndarray):
         raise ValueError("Input data must be a NumPy array.")
+    
+    if dtype == "int32":
+        # n = 32
+        np_dtype = np.int32
+        fill_value = np.iinfo(np.int32).min  # -2147483648
+        clip_min = np.iinfo(np.int32).min + 1  # -2147483647
+        clip_max = np.iinfo(np.int32).max  # 2147483647
+    elif dtype == "int16":
+        # n = 16
+        np_dtype = np.int16
+        fill_value = np.iinfo(np.int16).min  # -32768
+        clip_min = np.iinfo(np.int16).min + 1  # -32767
+        clip_max = np.iinfo(np.int16).max  # 32767
+    else:
+        raise ValueError("Unsupported dtype. Supported types are 'int16' and 'int32'.")
+
+    # 创建掩码，只排除 NaN/inf 和显式的填充值
+    valid_mask = np.isfinite(data)
+    valid_mask &= data != fill_value
+
+    # 如果数据有掩码属性，还需考虑掩码
+    if hasattr(data, "mask") and np.ma.is_masked(data):
+        # 只有掩码标记的区域视为无效
+        valid_mask &= ~data.mask
 
-    # 先计算转换后的数据
-    result = np.around((data - offset) / scale)
-    # 替换 NaN, 正负无穷（posinf, neginf）为 -32767
-    result = np.nan_to_num(result, nan=-32767, posinf=-32767, neginf=-32767)
-    result = np.clip(result, -32767, 32767)  # 限制范围在 int16 的有效范围内
-    result = np.where(np.isfinite(result), result, -32767)  # 替换无效值为 -32767
-    new_data = result.astype(np.int16)
-    return new_data
+    result = data.copy()
+    if np.any(valid_mask):
+        # 反向映射时能还原原始值
+        scaled = (data[valid_mask] - offset) / scale
+        scaled = np.round(scaled).astype(np_dtype)
+        # clip到int32范围，保留最大范围供转换
+        scaled = np.clip(scaled, clip_min, clip_max)  # 不使用 -2147483648，保留做 _FillValue
+        result[valid_mask] = scaled
+    return result
 
 
-def save_to_nc(file, data, varname=None, coords=None, mode="w", scale_offset_switch=True, compile_switch=True):
+def save_to_nc(file, data, varname=None, coords=None, mode="w", convert_dtype='int32',scale_offset_switch=True, compile_switch=True, preserve_mask_values=True):
     """
     保存数据到 NetCDF 文件，支持 xarray 对象（DataArray 或 Dataset）和 numpy 数组。
 
-    仅对数据变量中数值型数据进行压缩转换（利用 scale_factor/add_offset 转换后转为 int16），
+    仅对数据变量中数值型数据进行压缩转换（利用 scale_factor/add_offset 转换后转为 int32），
     非数值型数据以及所有坐标变量将禁用任何压缩，直接保存原始数据。
 
     参数：
@@ -130,64 +165,134 @@ def save_to_nc(file, data, varname=None, coords=None, mode="w", scale_offset_swi
       - varname: 变量名（仅适用于传入 numpy 数组或 DataArray 时）
       - coords: 坐标字典（numpy 数组分支时使用），所有坐标变量均不压缩
       - mode: "w"（覆盖）或 "a"（追加）
+      - convert_dtype: 转换为的数值类型（"int16" 或 "int32"），默认为 "int32"
       - scale_offset_switch: 是否对数值型数据变量进行压缩转换
       - compile_switch: 是否启用 NetCDF4 的 zlib 压缩（仅针对数值型数据有效）
+      - missing_value: 自定义缺失值，将被替换为 fill_value
+      - preserve_mask_values: 是否保留掩码区域的原始值（True）或将其替换为缺省值（False）
     """
+    if convert_dtype not in ["int16", "int32"]:
+        convert_dtype = "int32"
+    nc_dtype = _numpy_to_nc_type(convert_dtype)
+    # fill_value = np.iinfo(np.convert_dtype).min  # -2147483648 或 -32768
+    # fill_value = np.iinfo(eval('np.' + convert_dtype)).min  # -2147483648 或 -32768
+    np_dtype = getattr(np, convert_dtype)  # 更安全的类型获取方式
+    fill_value = np.iinfo(np_dtype).min
+    # ----------------------------------------------------------------------------
     # 处理 xarray 对象（DataArray 或 Dataset）的情况
     if isinstance(data, (xr.DataArray, xr.Dataset)):
-        encoding = {}  # 用于保存数据变量的编码信息
+        encoding = {}
 
         if isinstance(data, xr.DataArray):
             if data.name is None:
                 data = data.rename("data")
             varname = data.name if varname is None else varname
-            # 判断数据是否为数值型
-            if np.issubdtype(data.values.dtype, np.number) and scale_offset_switch:
-                scale, offset = _calculate_scale_and_offset(data.values)
-                new_values = _data_to_scale_offset(data.values, scale, offset)
-                # 生成新 DataArray，保留原坐标和属性，同时写入转换参数到属性中
+            arr = np.array(data.values)
+            try:
+                data_missing_val = data.attrs.get("missing_value")
+            except AttributeError:
+                data_missing_val = data.attrs.get("_FillValue", None)
+            # 只对有效数据计算scale/offset
+            valid_mask = np.ones(arr.shape, dtype=bool)  # 默认所有值都有效
+            if arr.dtype.kind in ["f", "i", "u"]:  # 仅对数值数据应用isfinite
+                valid_mask = np.isfinite(arr)
+                if data_missing_val is not None:
+                    valid_mask &= arr != data_missing_val
+                if hasattr(arr, "mask"):
+                    valid_mask &= ~getattr(arr, "mask", False)
+            if np.issubdtype(arr.dtype, np.number) and scale_offset_switch:
+                arr_valid = arr[valid_mask]
+                scale, offset = _calculate_scale_and_offset(arr_valid, convert_dtype)
+                # 写入前处理无效值（只在这里做！）
+                arr_to_save = arr.copy()
+                # 处理自定义缺失值
+                if data_missing_val is not None:
+                    arr_to_save[arr == data_missing_val] = fill_value
+                # 处理 NaN/inf
+                arr_to_save[~np.isfinite(arr_to_save)] = fill_value
+                new_values = _data_to_scale_offset(arr_to_save, scale, offset)
                 new_da = data.copy(data=new_values)
+                # 移除 _FillValue 和 missing_value 属性
+                for k in ["_FillValue", "missing_value"]:
+                    if k in new_da.attrs:
+                        del new_da.attrs[k]
                 new_da.attrs["scale_factor"] = float(scale)
                 new_da.attrs["add_offset"] = float(offset)
                 encoding[varname] = {
                     "zlib": compile_switch,
                     "complevel": 4,
-                    "dtype": "int16",
-                    "_FillValue": -32767,
+                    "dtype": nc_dtype,
+                    # "_FillValue": -2147483648,
                 }
                 new_da.to_dataset(name=varname).to_netcdf(file, mode=mode, encoding=encoding)
             else:
+                for k in ["_FillValue", "missing_value"]:
+                    if k in data.attrs:
+                        del data.attrs[k]
                 data.to_dataset(name=varname).to_netcdf(file, mode=mode)
-            _nan_to_fillvalue(file)  # 替换 NaN 为 _FillValue
+            _nan_to_fillvalue(file, fill_value)
             return
 
-        else:
-            # 处理 Dataset 的情况，仅处理 data_vars 数据变量，坐标变量保持原样
+        else:  # Dataset 情况
             new_vars = {}
             encoding = {}
             for var in data.data_vars:
                 da = data[var]
-                if np.issubdtype(np.asarray(da.values).dtype, np.number) and scale_offset_switch:
-                    scale, offset = _calculate_scale_and_offset(da.values)
-                    new_values = _data_to_scale_offset(da.values, scale, offset)
-                    new_da = xr.DataArray(new_values, dims=da.dims, coords=da.coords, attrs=da.attrs)
+                arr = np.array(da.values)
+                try:
+                    data_missing_val = da.attrs.get("missing_value")
+                except AttributeError:
+                    data_missing_val = da.attrs.get("_FillValue", None)
+                valid_mask = np.ones(arr.shape, dtype=bool)  # 默认所有值都有效
+                if arr.dtype.kind in ["f", "i", "u"]:  # 仅对数值数据应用isfinite
+                    valid_mask = np.isfinite(arr)
+                    if data_missing_val is not None:
+                        valid_mask &= arr != data_missing_val
+                    if hasattr(arr, "mask"):
+                        valid_mask &= ~getattr(arr, "mask", False)
+
+                # 创建属性的副本以避免修改原始数据集
+                attrs = da.attrs.copy()
+                for k in ["_FillValue", "missing_value"]:
+                    if k in attrs:
+                        del attrs[k]
+
+                if np.issubdtype(arr.dtype, np.number) and scale_offset_switch:
+                    # 处理边缘情况：检查是否有有效数据
+                    if not np.any(valid_mask):
+                        # 如果没有有效数据，创建一个简单的拷贝，不做转换
+                        new_vars[var] = xr.DataArray(arr, dims=da.dims, coords=da.coords, attrs=attrs)
+                        continue
+
+                    arr_valid = arr[valid_mask]
+                    scale, offset = _calculate_scale_and_offset(arr_valid, convert_dtype)
+                    arr_to_save = arr.copy()
+
+                    # 使用与DataArray相同的逻辑，使用_data_to_scale_offset处理数据
+                    # 处理自定义缺失值
+                    if data_missing_val is not None:
+                        arr_to_save[arr == data_missing_val] = fill_value
+                    # 处理 NaN/inf
+                    arr_to_save[~np.isfinite(arr_to_save)] = fill_value
+                    new_values = _data_to_scale_offset(arr_to_save, scale, offset)
+                    new_da = xr.DataArray(new_values, dims=da.dims, coords=da.coords, attrs=attrs)
                     new_da.attrs["scale_factor"] = float(scale)
                     new_da.attrs["add_offset"] = float(offset)
+                    # 不设置_FillValue属性，改为使用missing_value
+                    # new_da.attrs["missing_value"] = -2147483648
                     new_vars[var] = new_da
                     encoding[var] = {
                         "zlib": compile_switch,
                         "complevel": 4,
-                        "dtype": "int16",
-                        "_FillValue": -32767,
+                        "dtype": nc_dtype,
                     }
                 else:
-                    new_vars[var] = da
-            new_ds = xr.Dataset(new_vars, coords=data.coords)
-            if encoding:
-                new_ds.to_netcdf(file, mode=mode, encoding=encoding)
-            else:
-                new_ds.to_netcdf(file, mode=mode)
-        _nan_to_fillvalue(file)  # 替换 NaN 为 _FillValue
+                    new_vars[var] = xr.DataArray(arr, dims=da.dims, coords=da.coords, attrs=attrs)
+
+            # 确保坐标变量被正确复制
+            new_ds = xr.Dataset(new_vars, coords=data.coords.copy())
+            new_ds.to_netcdf(file, mode=mode, encoding=encoding if encoding else None)
+        _nan_to_fillvalue(file, fill_value)
         return
 
     # 处理纯 numpy 数组情况
@@ -197,9 +302,16 @@ def save_to_nc(file, data, varname=None, coords=None, mode="w", scale_offset_swi
         mode = "w"
     data = np.asarray(data)
     is_numeric = np.issubdtype(data.dtype, np.number)
+
+    if hasattr(data, "mask") and np.ma.is_masked(data):
+        # 处理掩码数组，获取缺失值
+        data = data.data
+        missing_value = getattr(data, "missing_value", None)
+    else:
+        missing_value = None
+    
     try:
         with nc.Dataset(file, mode, format="NETCDF4") as ncfile:
-            # 坐标变量直接写入，不做压缩
             if coords is not None:
                 for dim, values in coords.items():
                     if dim not in ncfile.dimensions:
@@ -209,45 +321,147 @@ def save_to_nc(file, data, varname=None, coords=None, mode="w", scale_offset_swi
 
             dims = list(coords.keys()) if coords else []
             if is_numeric and scale_offset_switch:
-                scale, offset = _calculate_scale_and_offset(data)
-                new_data = _data_to_scale_offset(data, scale, offset)
-                var = ncfile.createVariable(varname, "i2", dims, fill_value=-32767, zlib=compile_switch)
+                arr = np.array(data)
+
+                # 构建有效掩码，但不排除掩码区域的数值（如果 preserve_mask_values 为 True）
+                valid_mask = np.isfinite(arr)  # 排除 NaN 和无限值
+                if missing_value is not None:
+                    valid_mask &= arr != missing_value  # 排除明确的缺失值
+
+                # 如果不保留掩码区域的值，则将掩码区域视为无效
+                if not preserve_mask_values and hasattr(arr, "mask"):
+                    valid_mask &= ~arr.mask
+
+                arr_to_save = arr.copy()
+
+                # 确保有有效数据
+                if not np.any(valid_mask):
+                    # 如果没有有效数据，不进行压缩，直接保存原始数据类型
+                    dtype = _numpy_to_nc_type(data.dtype)
+                    var = ncfile.createVariable(varname, dtype, dims, zlib=False)
+                    # 确保没有 NaN
+                    clean_data = np.nan_to_num(data, nan=missing_value if missing_value is not None else fill_value)
+                    var[:] = clean_data
+                    return
+
+                # 计算 scale 和 offset 仅使用有效区域数据
+                arr_valid = arr_to_save[valid_mask]
+                scale, offset = _calculate_scale_and_offset(arr_valid, convert_dtype)
+
+                # 执行压缩转换
+                new_data = _data_to_scale_offset(arr_to_save, scale, offset)
+
+                # 创建变量并设置属性
+                var = ncfile.createVariable(varname, nc_dtype, dims, zlib=compile_switch)
                 var.scale_factor = scale
                 var.add_offset = offset
-                # Ensure no invalid values in new_data before assignment
+                var._FillValue = fill_value  # 明确设置填充值
                 var[:] = new_data
             else:
-                # 非数值型数据，禁止压缩
                 dtype = _numpy_to_nc_type(data.dtype)
                 var = ncfile.createVariable(varname, dtype, dims, zlib=False)
-                var[:] = data
-        _nan_to_fillvalue(file)  # 替换 NaN 为 _FillValue
+                # 确保不写入 NaN
+                if np.issubdtype(data.dtype, np.floating) and np.any(~np.isfinite(data)):
+                    fill_val = missing_value if missing_value is not None else fill_value
+                    var._FillValue = fill_val
+                    clean_data = np.nan_to_num(data, nan=fill_val)
+                    var[:] = clean_data
+                else:
+                    var[:] = data
+        # 最后确保所有 NaN 值被处理
+        _nan_to_fillvalue(file, fill_value)
     except Exception as e:
         raise RuntimeError(f"netCDF4 保存失败: {str(e)}") from e
 
 
+def _compress_netcdf(src_path, dst_path=None, tolerance=1e-10, preserve_mask_values=True):
+    """
+    压缩 NetCDF 文件，使用 scale_factor/add_offset 压缩数据。
+    若 dst_path 省略，则自动生成新文件名，写出后删除原文件并将新文件改回原名。
+    压缩后验证数据是否失真。
+
+    参数：
+      - src_path: 原始 NetCDF 文件路径
+      - dst_path: 压缩后的文件路径（可选）
+      - tolerance: 数据验证的允许误差范围（默认 1e-10）
+      - preserve_mask_values: 是否保留掩码区域的原始值（True）或将其替换为缺省值（False）
+    """
+    # 判断是否要替换原文件
+    delete_orig = dst_path is None
+    if delete_orig:
+        dst_path = src_path.replace(".nc", "_compress.nc")
+    # 打开原始文件并保存压缩文件
+    ds = xr.open_dataset(src_path)
+    save_to_nc(dst_path, ds, convert_dtype='int32',scale_offset_switch=True, compile_switch=True, preserve_mask_values=preserve_mask_values)
+    ds.close()
+
+    # 验证压缩后的数据是否失真
+    original_ds = xr.open_dataset(src_path)
+    compressed_ds = xr.open_dataset(dst_path)
+    # 更详细地验证数据
+    for var in original_ds.data_vars:
+        original_data = original_ds[var].values
+        compressed_data = compressed_ds[var].values
+        # 跳过非数值类型变量
+        if not np.issubdtype(original_data.dtype, np.number):
+            continue
+        # 获取掩码（如果存在）
+        original_mask = None
+        if hasattr(original_data, "mask") and np.ma.is_masked(original_data):  # 修正：确保是有效的掩码数组
+            original_mask = original_data.mask.copy()
+        # 检查有效数据是否在允许误差范围内
+        valid_mask = np.isfinite(original_data)
+        if original_mask is not None:
+            valid_mask &= ~original_mask
+        if np.any(valid_mask):
+            if np.issubdtype(original_data.dtype, np.floating):
+                diff = np.abs(original_data[valid_mask] - compressed_data[valid_mask])
+                max_diff = np.max(diff)
+                if max_diff > tolerance:
+                    print(f"警告: 变量 {var} 的压缩误差 {max_diff} 超出容许范围 {tolerance}")
+                    if max_diff > tolerance * 10:  # 严重偏差时抛出错误
+                        raise ValueError(f"变量 {var} 的数据在压缩后严重失真 (max_diff={max_diff})")
+            elif np.issubdtype(original_data.dtype, np.integer):
+                # 整数类型应该完全相等
+                if not np.array_equal(original_data[valid_mask], compressed_data[valid_mask]):
+                    raise ValueError(f"变量 {var} 的整数数据在压缩后不一致")
+        # 如果需要保留掩码区域值，检查掩码区域的值
+        if preserve_mask_values and original_mask is not None and np.any(original_mask):
+            # 确保掩码区域的原始值被正确保留
+            # 修正：掩码数组可能存在数据类型不匹配问题，添加安全检查
+            try:
+                mask_diff = np.abs(original_data[original_mask] - compressed_data[original_mask])
+                if np.any(mask_diff > tolerance):
+                    print(f"警告: 变量 {var} 的掩码区域数据在压缩后发生变化")
+            except Exception as e:
+                print(f"警告: 变量 {var} 的掩码区域数据比较失败: {str(e)}")
+    original_ds.close()
+    compressed_ds.close()
+
+    # 替换原文件
+    if delete_orig:
+        os.remove(src_path)
+        os.rename(dst_path, src_path)
+
+
 # 测试用例
 if __name__ == "__main__":
-    # --------------------------------
-    # dataset
-    file = r"F:\roms_rst.nc"
+    # 示例文件路径，需根据实际情况修改
+    file = "dataset_test.nc"
     ds = xr.open_dataset(file)
-    outfile = r"F:\roms_rst_test.nc"
+    outfile = "dataset_test_compressed.nc"
     save_to_nc(outfile, ds)
     ds.close()
-    # --------------------------------
+
     # dataarray
     data = np.random.rand(4, 3, 2)
     coords = {"x": np.arange(4), "y": np.arange(3), "z": np.arange(2)}
     varname = "test_var"
     data = xr.DataArray(data, dims=("x", "y", "z"), coords=coords, name=varname)
-    outfile = r"F:\test_dataarray.nc"
+    outfile = "test_dataarray.nc"
     save_to_nc(outfile, data)
-    # --------------------------------
-    # numpy array
-    data = np.random.rand(4, 3, 2)
-    coords = {"x": np.arange(4), "y": np.arange(3), "z": np.arange(2)}
-    varname = "test_var"
-    outfile = r"F:\test_numpy.nc"
-    save_to_nc(outfile, data, varname=varname, coords=coords)
-    # --------------------------------
+
+    # numpy array with custom missing value
+    coords = {"dim0": np.arange(5)}
+    data = np.array([1, 2, -999, 4, np.nan])
+    save_to_nc("test_numpy_missing.nc", data, varname="data", coords=coords, missing_value=-999)

oafuncs/oa_cmap.py

@@ -8,7 +8,9 @@ __all__ = ["show", "to_color", "create", "get"]
 
 
 # ** 将cmap用填色图可视化（官网摘抄函数）
-def show(colormaps: Union[str, mpl.colors.Colormap, List[Union[str, mpl.colors.Colormap]]]) -> None:
+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
@@ -97,7 +99,14 @@ def to_color(colormap_name: str, num_colors: int = 256) -> List[tuple]:
 
 
 # ** 自制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:
+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:
@@ -144,7 +153,7 @@ def create(color_list: Optional[List[Union[str, tuple]]] = None, rgb_file: Optio
 
     if rgb_file:
         try:
-            print(f"Reading RGB data from {rgb_file}...")
+            # 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("#")]
@@ -178,7 +187,7 @@ def create(color_list: Optional[List[Union[str, tuple]]] = None, rgb_file: Optio
             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}")
+            # print(f"Successfully created colormap from {rgb_file}")
         except FileNotFoundError:
             error_msg = f"RGB file not found: {rgb_file}"
             print(error_msg)
@@ -189,15 +198,15 @@ def create(color_list: Optional[List[Union[str, tuple]]] = None, rgb_file: Optio
             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")
+        # 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}")
+        # 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}")
+        # print(f"Set above-range color to {above_range_color}")
 
     return cmap_color
 
@@ -246,12 +255,12 @@ def get(colormap_name: Optional[str] = None, show_available: bool = False) -> Op
         return None
 
     if colormap_name in my_cmap_dict:
-        print(f"Using custom colormap: {colormap_name}")
+        # 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}")
+            # print(f"Using matplotlib colormap: {colormap_name}")
             return cmap
         except ValueError:
             print(f"Warning: Unknown cmap name: {colormap_name}")

oafuncs/oa_down/hycom_3hourly.py

@@ -1,18 +1,3 @@
-#!/usr/bin/env python
-# coding=utf-8
-"""
-Author: Liu Kun && 16031215@qq.com
-Date: 2025-04-07 10:51:09
-LastEditors: Liu Kun && 16031215@qq.com
-LastEditTime: 2025-04-07 10:51:09
-FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\oa_down\\hycom_3hourly copy.py
-Description:
-EditPlatform: vscode
-ComputerInfo: XPS 15 9510
-SystemInfo: Windows 11
-Python Version: 3.12
-"""
-
 import asyncio
 import datetime
 import logging
@@ -23,7 +8,6 @@ import warnings
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from threading import Lock
-from oafuncs.oa_tool import pbar
 
 import httpx
 import matplotlib.pyplot as plt
@@ -38,6 +22,7 @@ from oafuncs.oa_down.user_agent import get_ua
 from oafuncs.oa_file import file_size
 from oafuncs.oa_nc import check as check_nc
 from oafuncs.oa_nc import modify as modify_nc
+from oafuncs.oa_tool import pbar
 
 logging.getLogger("httpx").setLevel(logging.WARNING)  # 关闭 httpx 的 INFO 日志，只显示 WARNING 及以上
 
@@ -724,7 +709,6 @@ class _HycomDownloader:
                                     logging.info(f"{file_name}: {percent}% ({downloaded / 1024:.1f} KB / {total / 1024:.1f} KB)")
                                     last_percent = percent
 
-
                     elapsed = datetime.datetime.now() - start
                     # logging.info(f"File {file_name} downloaded, Time: {elapsed}")
                     logging.info(f"Saving {file_name} ...")
@@ -966,7 +950,7 @@ def _download_hourly_func(var, time_s, time_e, lon_min=0, lon_max=359.92, lat_mi
             print("Downloading a series of files...")
         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))
+        # task = progress.add_task(f"[cyan]{bar_desc}", total=len(time_list))
         if num_workers is None or num_workers <= 1:
             for i, time_str in pbar(enumerate(time_list), description=f"{bar_desc}", total=len(time_list), next_line=True):
                 _prepare_url_to_download(var, lon_min, lon_max, lat_min, lat_max, time_str, None, depth, level, store_path, dataset_name, version_name, cover)
@@ -976,7 +960,7 @@ def _download_hourly_func(var, time_s, time_e, lon_min=0, lon_max=359.92, lat_mi
                 futures = [executor.submit(_download_task, var, time_str, None, lon_min, lon_max, lat_min, lat_max, depth, level, store_path, dataset_name, version_name, cover) for time_str in time_list]
                 """ for feature in as_completed(futures):
                     _done_callback(feature, progress, task, len(time_list), counter_lock) """
-                for _ in pbar(as_completed(futures),description=f"{bar_desc}", total=len(futures),next_line=True):
+                for _ in pbar(as_completed(futures), description=f"{bar_desc}", total=len(futures), next_line=True):
                     pass
     else:
         print("[bold red]Please ensure the time_s is no more than time_e")
@@ -1174,7 +1158,7 @@ def download(
 
     count_dict["total"] = count_dict["success"] + count_dict["fail"] + count_dict["skip"] + count_dict["no_data"]
     print("[bold #ecdbfe]=" * mark_len)
-    print(f"[bold #ff80ab]Total: {count_dict['total']}\nSuccess: {count_dict['success']}\nFail: {count_dict['fail']}\nSkip: {count_dict['skip']}\nNo data: {count_dict['no_data']}")
+    print(f"[bold #ff80ab]Total  : {count_dict['total']}\nSuccess: {count_dict['success']}\nFail   : {count_dict['fail']}\nSkip   : {count_dict['skip']}\nNo data: {count_dict['no_data']}")
     print("[bold #ecdbfe]=" * mark_len)
     if count_dict["fail"] > 0:
         print("[bold #be5528]Please try again to download the failed data later.")

oafuncs/oa_draw.py

@@ -318,7 +318,7 @@ def add_gridlines(axes: plt.Axes, longitude_lines: list[float] = None, latitude_
     if latitude_lines is not None:
         gl.ylocator = mticker.FixedLocator(np.array(latitude_lines))
 
-    print("[green]Gridlines added successfully.[/green]")
+    # print("[green]Gridlines added successfully.[/green]")
     return axes, gl
 
 
@@ -365,7 +365,7 @@ def add_cartopy(axes: plt.Axes, longitude_data: np.ndarray = None, latitude_data
         lat_min, lat_max = np.nanmin(latitude_data), np.nanmax(latitude_data)
         axes.set_extent([lon_min, lon_max, lat_min, lat_max], crs=map_projection)
 
-    print("[green]Cartopy features added successfully.[/green]")
+    # print("[green]Cartopy features added successfully.[/green]")
     return axes
 
 

oafuncs/oa_nc.py

@@ -6,7 +6,8 @@ import numpy as np
 import xarray as xr
 from rich import print
 
-__all__ = ["save", "merge", "modify", "rename", "check", "convert_longitude", "isel", "draw", "compress_netcdf", "unpack_netcdf"]
+__all__ = ["save", "merge", "modify", "rename", "check", "convert_longitude", "isel", "draw", "compress", "unscale"]
+
 
 
 def save(
@@ -15,8 +16,10 @@ def save(
     variable_name: Optional[str] = None,
     coordinates: Optional[dict] = None,
     write_mode: str = "w",
+    convert_dtype: str = "int32",
     use_scale_offset: bool = True,
     use_compression: bool = True,
+    preserve_mask_values: bool = True,
 ) -> None:
     """
     Write data to a NetCDF file.
@@ -27,8 +30,10 @@ def save(
         variable_name (Optional[str]): Variable name for the data.
         coordinates (Optional[dict]): Coordinates, where keys are dimension names and values are coordinate data.
         write_mode (str): Write mode, 'w' for write, 'a' for append. Default is 'w'.
+        convert_dtype (str): Data type to convert to. Default is 'int32'.
         use_scale_offset (bool): Whether to use scale_factor and add_offset. Default is True.
         use_compression (bool): Whether to use compression parameters. Default is True.
+        preserve_mask_values (bool): Whether to preserve mask values. Default is True.
 
     Example:
         >>> save(r'test.nc', data, 'u', {'time': np.linspace(0, 120, 100), 'lev': np.linspace(0, 120, 50)}, 'a')
@@ -38,7 +43,7 @@ def save(
     """
     from ._script.netcdf_write import save_to_nc
 
-    save_to_nc(file_path, data, variable_name, coordinates, write_mode, use_scale_offset, use_compression)
+    save_to_nc(file_path, data, variable_name, coordinates, write_mode, convert_dtype,use_scale_offset, use_compression, preserve_mask_values)
     print(f"[green]Data successfully saved to {file_path}[/green]")
 
 
@@ -278,7 +283,7 @@ def draw(
         print("[red]No dataset or file provided.[/red]")
 
 
-def compress_netcdf(src_path, dst_path=None):
+def compress(src_path, dst_path=None,convert_dtype='int16'):
     """
     压缩 NetCDF 文件，使用 scale_factor/add_offset 压缩数据。
     若 dst_path 省略，则自动生成新文件名，写出后删除原文件并将新文件改回原名。
@@ -289,7 +294,7 @@ def compress_netcdf(src_path, dst_path=None):
         dst_path = src_path.replace(".nc", "_compress.nc")
 
     ds = xr.open_dataset(src_path)
-    save(dst_path, ds)
+    save(dst_path, ds, convert_dtype=convert_dtype, use_scale_offset=True, use_compression=True)
     ds.close()
 
     if delete_orig:
@@ -298,26 +303,88 @@ def compress_netcdf(src_path, dst_path=None):
     pass
 
 
-def unpack_netcdf(src_path, dst_path=None):
+def unscale(src_path, dst_path=None, compression_level=4):
     """解码 NetCDF 并移除 scale_factor/add_offset，写出真实值。
+    保留压缩功能，但不使用比例因子和偏移量，以控制文件大小。
     若 dst_path 省略，则自动生成新文件名，写出后删除原文件并将新文件改回原名。
+
+    Args:
+        src_path: 源文件路径
+        dst_path: 目标文件路径，None则替换原文件
+        compression_level: 压缩级别(1-9)，数值越大压缩比越高，速度越慢
     """
     # 判断是否要替换原文件
     delete_orig = dst_path is None
     if delete_orig:
         dst_path = src_path.replace(".nc", "_unpacked.nc")
 
+    # 打开原始文件，获取文件大小
+    orig_size = os.path.getsize(src_path) / (1024 * 1024)  # MB
+
+    # 先以原始模式打开，查看哪些变量使用了scale_factor/add_offset
+    with xr.open_dataset(src_path, decode_cf=False) as ds_raw:
+        has_scaling = []
+        for var in ds_raw.data_vars:
+            if "scale_factor" in ds_raw[var].attrs or "add_offset" in ds_raw[var].attrs:
+                has_scaling.append(var)
+
+    print(f"[yellow]文件: {src_path} (原始大小: {orig_size:.2f} MB)[/yellow]")
+    if has_scaling:
+        print(f"[yellow]发现 {len(has_scaling)} 个变量使用了比例因子: {', '.join(has_scaling)}[/yellow]")
+    else:
+        print("[yellow]未发现任何变量使用比例因子，解包可能不必要[/yellow]")
+
+    # 解码模式打开
     ds = xr.open_dataset(src_path, decode_cf=True)
+    encoding = {}
+
     for var in ds.data_vars:
+        # 保存原始的_FillValue
+        fill_value = None
+        if "_FillValue" in ds[var].attrs:
+            fill_value = ds[var].attrs["_FillValue"]
+        elif "_FillValue" in ds[var].encoding:
+            fill_value = ds[var].encoding["_FillValue"]
+
+        # 清除scale_factor和add_offset属性
         ds[var].attrs.pop("scale_factor", None)
         ds[var].attrs.pop("add_offset", None)
         ds[var].encoding.clear()
-    ds.to_netcdf(dst_path, mode="w", format="NETCDF4", engine="netcdf4")
+
+        # 仅对数值型变量处理
+        if np.issubdtype(ds[var].dtype, np.number):
+            # 强制转换为float32，避免float64导致文件暴涨
+            if np.issubdtype(ds[var].dtype, np.floating) and ds[var].dtype != np.float32:
+                ds[var] = ds[var].astype(np.float32)
+
+            # 设置压缩参数，但不使用scale_factor/add_offset
+            encoding[var] = {"zlib": True, "complevel": compression_level, "dtype": ds[var].dtype}
+            # 恢复_FillValue
+            if fill_value is not None:
+                encoding[var]["_FillValue"] = fill_value
+
+    # 使用save函数保存，传入encoding确保只压缩不使用scale_factor
+    ds.to_netcdf(dst_path, encoding=encoding)
     ds.close()
 
+    # 打印输出文件大小对比
+    if os.path.exists(dst_path):
+        new_size = os.path.getsize(dst_path) / (1024 * 1024)  # MB
+        size_change = new_size - orig_size
+        change_percent = (size_change / orig_size) * 100
+
+        color = "green" if size_change <= 0 else "red"
+        print(f"[{color}]解包后文件大小: {new_size:.2f} MB ({change_percent:+.1f}%)[/{color}]")
+
+        if size_change > orig_size * 0.5 and new_size > 100:  # 如果文件增长超过50%且大于100MB
+            print(f"[red]警告: 文件大小增长显著! 考虑增加压缩级别(当前:{compression_level})[/red]")
+
     if delete_orig:
         os.remove(src_path)
         os.rename(dst_path, src_path)
+        print(f"[green]已替换原文件: {src_path}[/green]")
+    else:
+        print(f"[green]已保存到: {dst_path}[/green]")
 
 
 if __name__ == "__main__":

oafuncs/oa_tool.py

@@ -135,7 +135,7 @@ def email(title: str = "Title", content: Optional[str] = None, send_to: str = "1
 
 def pbar(
     iterable: Iterable = range(100),
-    description: str = "Working...",
+    description: str = "Working",
     total: Optional[float] = None,
     completed: float = 0,
     color: Any = "None",

{oafuncs-0.0.98.20.dist-info → oafuncs-0.0.98.22.dist-info}/METADATA

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

{oafuncs-0.0.98.20.dist-info → oafuncs-0.0.98.22.dist-info}/RECORD

@@ -1,29 +1,29 @@
 oafuncs/__init__.py,sha256=T_-VtnWWllV3Q91twT5Yt2sUapeA051QbPNnBxmg9nw,1456
-oafuncs/oa_cmap.py,sha256=DimWT4Bg7uE5Lx8hSw1REp7whpsR2pFRStAwk1cowEM,11494
+oafuncs/oa_cmap.py,sha256=pUFAGzbIg0WLxObBP2t_--ZIg00Dxdojx0y7OjTeqEo,11551
 oafuncs/oa_data.py,sha256=Aat9ktxxRGevaqQya3IJWfXeoEs-FCXGUcNE2pKnzfU,10931
 oafuncs/oa_date.py,sha256=WhM6cyD4G3IeghjLTHhAMtlvJbA7kwQG2sHnxdTgyso,6303
-oafuncs/oa_draw.py,sha256=Wj2QBgyIPpV_dxaDrH10jqj_puK9ZM9rd-si-3VrsrE,17631
+oafuncs/oa_draw.py,sha256=IaBGDx-EOxyMM2IuJ4zLZt6ruHHV5qFStPItmUOXoWk,17635
 oafuncs/oa_file.py,sha256=j9gXJgPOJsliu4IOUc4bc-luW4yBvQyNCEmMyDVjUwQ,16404
 oafuncs/oa_help.py,sha256=_4AZgRDq5Or0vauNvq5IDDHIBoBfdOQtzak-mG1wwAw,4537
-oafuncs/oa_nc.py,sha256=lLEPjj4qgdEw1al0r1nKGZUnMP_ejT8A2NKD4lrs2kc,11936
+oafuncs/oa_nc.py,sha256=UUXnBg2cO5XiJ8w0jNqCZJg83FVKqxlEHxOJG5o08Z8,15201
 oafuncs/oa_python.py,sha256=NkopwkYFGSEuVljnTBvXCl6o2CeyRNBqRXSsUl3euEE,5192
-oafuncs/oa_tool.py,sha256=rpPkLqWhqMmqlCc5wjL8qMTg3gThCkSrYJckbX_0iJc,8631
+oafuncs/oa_tool.py,sha256=QBjJh3pf54yXVuOmu97rW6Tsr6uNMyZ5KqZbR4VQFTc,8628
 oafuncs/_data/hycom.png,sha256=MadKs6Gyj5n9-TOu7L4atQfTXtF9dvN9w-tdU9IfygI,10945710
 oafuncs/_data/oafuncs.png,sha256=o3VD7wm-kwDea5E98JqxXl04_78cBX7VcdUt7uQXGiU,3679898
 oafuncs/_script/cprogressbar.py,sha256=UIgGcLFs-6IgWlITuBLaQqrpt4OAK3Mst5RlCiNfZdQ,15772
 oafuncs/_script/data_interp.py,sha256=EiZbt6n5BEaRKcng88UgX7TFPhKE6TLVZniS01awXjg,5146
 oafuncs/_script/data_interp_geo.py,sha256=ZRFb3fKRiYQViZNHd19eW20C9i38BsiIU8w0fG5mbqM,7789
 oafuncs/_script/email.py,sha256=lL4HGKrr524-g0xLlgs-4u7x4-u7DtgNoD9AL8XJKj4,3058
-oafuncs/_script/netcdf_merge.py,sha256=zasqrFpB2GHAjZ1LkrWtI7kpHu7uCjdIGf4C0lEraYA,4816
+oafuncs/_script/netcdf_merge.py,sha256=tM9ePqLiEsE7eIsNM5XjEYeXwxjYOdNz5ejnEuI7xKw,6066
 oafuncs/_script/netcdf_modify.py,sha256=sGRUYNhfGgf9JV70rnBzw3bzuTRSXzBTL_RMDnDPeLQ,4552
-oafuncs/_script/netcdf_write.py,sha256=gEqeagAcu0_xa6cIuu7a5d9uXMEaGqnci02KNc5znEY,10672
+oafuncs/_script/netcdf_write.py,sha256=GvyUyUhzMonzSp3y4pT8ZAfbQrsh5J3dLnmINYJKhuE,21422
 oafuncs/_script/parallel.py,sha256=07-BJVHxXJNlrOrhrSGt7qCZiKWq6dBvNDBA1AANYnI,8861
 oafuncs/_script/parallel_test.py,sha256=0GBqZOX7IaCOKF2t1y8N8YYu53GJ33OkfsWgpvZNqM4,372
 oafuncs/_script/plot_dataset.py,sha256=zkSEnO_-biyagorwWXPoihts_cwuvripzEt-l9bHJ2E,13989
 oafuncs/_script/replace_file_content.py,sha256=eCFZjnZcwyRvy6b4mmIfBna-kylSZTyJRfgXd6DdCjk,5982
 oafuncs/oa_down/User_Agent-list.txt,sha256=pHaMlElMvZ8TG4vf4BqkZYKqe0JIGkr4kCN0lM1Y9FQ,514295
 oafuncs/oa_down/__init__.py,sha256=kRX5eTUCbAiz3zTaQM1501paOYS_3fizDN4Pa0mtNUA,585
-oafuncs/oa_down/hycom_3hourly.py,sha256=VYxG9DPAnS1wk8gEXyqSIww4IvNRWOYGC4D6PTh5t3A,55450
+oafuncs/oa_down/hycom_3hourly.py,sha256=R5fKfIcpNRuaQgPiov_hJRd8voWgAHVLWifAMzR6RQI,55075
 oafuncs/oa_down/hycom_3hourly_proxy.py,sha256=1eaoJGI_m-7w4ZZ3n7NGxkZaeFdsm0d3U-hyw8RFNbc,54563
 oafuncs/oa_down/idm.py,sha256=4z5IvgfTyIKEI1kOtqXZwN7Jnfjwp6qDBOIoVyOLp0I,1823
 oafuncs/oa_down/literature.py,sha256=2bF9gSKQbzcci9LcKE81j8JEjIJwON7jbwQB3gDDA3E,11331
@@ -39,8 +39,8 @@ oafuncs/oa_sign/__init__.py,sha256=QKqTFrJDFK40C5uvk48GlRRbGFzO40rgkYwu6dYxatM,5
 oafuncs/oa_sign/meteorological.py,sha256=8091SHo2L8kl4dCFmmSH5NGVHDku5i5lSiLEG5DLnOQ,6489
 oafuncs/oa_sign/ocean.py,sha256=xrW-rWD7xBWsB5PuCyEwQ1Q_RDKq2KCLz-LOONHgldU,5932
 oafuncs/oa_sign/scientific.py,sha256=a4JxOBgm9vzNZKpJ_GQIQf7cokkraV5nh23HGbmTYKw,5064
-oafuncs-0.0.98.20.dist-info/licenses/LICENSE.txt,sha256=rMtLpVg8sKiSlwClfR9w_Dd_5WubTQgoOzE2PDFxzs4,1074
-oafuncs-0.0.98.20.dist-info/METADATA,sha256=QgOUX1DWWv2bLiGauzfcJsKtuGQfyJkinMJoCO7FRdI,4273
-oafuncs-0.0.98.20.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-oafuncs-0.0.98.20.dist-info/top_level.txt,sha256=bgC35QkXbN4EmPHEveg_xGIZ5i9NNPYWqtJqaKqTPsQ,8
-oafuncs-0.0.98.20.dist-info/RECORD,,
+oafuncs-0.0.98.22.dist-info/licenses/LICENSE.txt,sha256=rMtLpVg8sKiSlwClfR9w_Dd_5WubTQgoOzE2PDFxzs4,1074
+oafuncs-0.0.98.22.dist-info/METADATA,sha256=ctJ9aAoY3RztAP6gD2STCFB0ZZaCbXQV8SufCLMGkbM,4273
+oafuncs-0.0.98.22.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+oafuncs-0.0.98.22.dist-info/top_level.txt,sha256=bgC35QkXbN4EmPHEveg_xGIZ5i9NNPYWqtJqaKqTPsQ,8
+oafuncs-0.0.98.22.dist-info/RECORD,,

{oafuncs-0.0.98.20.dist-info → oafuncs-0.0.98.22.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any