oafuncs 0.0.97.13__tar.gz → 0.0.97.14__tar.gz

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

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

oafuncs-0.0.97.14/oafuncs/_script/cprogressbar.py

@@ -0,0 +1,443 @@
+import random
+import re
+import shutil
+import sys
+import threading
+import time
+import warnings
+from collections import deque
+from typing import Any, Callable, Deque, Iterable, List, NamedTuple, Optional, Union
+
+import numpy as np
+from oafuncs.oa_cmap import get as get_cmap
+
+try:
+    # import matplotlib
+    from matplotlib.colors import LinearSegmentedColormap, to_hex, to_rgb
+except ImportError:
+    raise ImportError("This module requires matplotlib. Install with: pip install matplotlib")
+
+
+class ProgressSample(NamedTuple):
+    """进度采样点"""
+
+    timestamp: float
+    """采样时间戳"""
+    completed: float
+    """已完成步数"""
+
+
+class Task:
+    """进度任务信息类"""
+
+    def __init__(
+        self,
+        description: str,
+        total: Optional[float],
+        completed: float = 0,
+        visible: bool = True,
+        color: Any = "cyan",
+        get_time: Callable[[], float] = time.time,
+    ):
+        self.description = description
+        self.total = total
+        self.completed = completed
+        self.visible = visible
+        self.color = color
+        self._get_time = get_time
+
+        self.start_time: Optional[float] = None
+        self.stop_time: Optional[float] = None
+        self.finished_time: Optional[float] = None
+        self.finished_speed: Optional[float] = None
+        self._progress: Deque[ProgressSample] = deque(maxlen=1000)
+
+    def get_time(self) -> float:
+        """获取当前时间"""
+        return self._get_time()
+
+    def start(self) -> None:
+        """开始任务"""
+        if self.start_time is None:
+            self.start_time = self.get_time()
+
+    def stop(self) -> None:
+        """停止任务"""
+        if self.stop_time is None:
+            self.stop_time = self.get_time()
+
+    @property
+    def started(self) -> bool:
+        """任务是否已开始"""
+        return self.start_time is not None
+
+    @property
+    def finished(self) -> bool:
+        """任务是否已完成"""
+        return self.finished_time is not None
+
+    @property
+    def percentage(self) -> float:
+        """完成百分比"""
+        if not self.total:
+            return 0.0
+        completed = (self.completed / self.total) * 100.0
+        return min(100.0, max(0.0, completed))
+
+    @property
+    def elapsed(self) -> Optional[float]:
+        """已用时间"""
+        if self.start_time is None:
+            return None
+        if self.stop_time is not None:
+            return self.stop_time - self.start_time
+        return self.get_time() - self.start_time
+
+    @property
+    def remaining(self) -> Optional[float]:
+        """剩余步数"""
+        if self.total is None:
+            return None
+        return self.total - self.completed
+
+    @property
+    def speed(self) -> Optional[float]:
+        """估计速度（步数/秒）"""
+        if self.start_time is None:
+            return None
+
+        progress = self._progress
+        if not progress:
+            return None
+
+        total_time = progress[-1].timestamp - progress[0].timestamp
+        if total_time < 0.001:
+            return None
+
+        iter_progress = iter(progress)
+        next(iter_progress)
+        total_completed = sum(sample.completed for sample in iter_progress)
+
+        speed = total_completed / total_time
+        return speed
+
+    @property
+    def time_remaining(self) -> Optional[float]:
+        """预估剩余时间"""
+        if self.finished:
+            return 0.0
+
+        speed = self.speed
+        if not speed:
+            return None
+
+        remaining = self.remaining
+        if remaining is None:
+            return None
+
+        estimate = remaining / speed
+        return estimate
+
+
+class ColorProgressBar:
+    """彩色进度条，支持多种终端环境和颜色渐变效果"""
+
+    def __init__(
+        self,
+        iterable: Iterable,
+        description: str = "Working ...",
+        total: Optional[float] = None,
+        completed: float = 0,
+        color: Any = "cyan",
+        cmap: Union[str, List[str]] = None,
+        update_interval: float = 0.1,
+        bar_length: int = None,
+        speed_estimate_period: float = 30.0,
+    ):
+        self.iterable = iterable
+        self.description = description
+        self.color = color
+        self.cmap = cmap
+        self.update_interval = update_interval
+        self.bar_length = bar_length
+        self.speed_estimate_period = speed_estimate_period
+        self.mark_num = random.randint(0, 13)  # 随机选择填充字符的数量
+
+        # 线程安全锁
+        self._lock = threading.RLock()
+
+        # 尝试获取总数
+        if total is None and hasattr(iterable, "__len__"):
+            total = len(iterable)
+
+        # 创建任务
+        self.task = Task(
+            description=description,
+            total=total,
+            completed=completed,
+            color=color,
+        )
+
+        # 输出和渲染相关
+        self._file = sys.stdout
+        self._gradient_colors = self._generate_gradient() if cmap and self.task.total else None
+        self._last_update_time = 0
+
+        # 检测终端环境
+        self._is_terminal = hasattr(self._file, "isatty") and self._file.isatty()
+        self._is_jupyter = "ipykernel" in sys.modules
+
+    def _generate_gradient(self) -> Optional[List[str]]:
+        """生成渐变色列表（修复内置colormap支持）"""
+        try:
+            if isinstance(self.cmap, list):
+                cmap = LinearSegmentedColormap.from_list("custom_cmap", self.cmap)
+            elif hasattr(self.cmap, "__call__") and hasattr(self.cmap, "N"):
+                # 直接处理已经是colormap对象的情况
+                cmap = self.cmap
+            else:
+                cmap = get_cmap(self.cmap)  # 使用oafuncs.oa_cmap.get获取内置colormap；也可获取原本自定义的colormap
+
+            return [to_hex(cmap(i)) for i in np.linspace(0, 1, int(self.task.total))]
+        except Exception as e:
+            warnings.warn(f"Colormap generation failed: {str(e)}. cmap type: {type(self.cmap)}")
+            return None
+
+    def _hex_to_ansi(self, hex_color: str) -> str:
+        """将颜色转换为ANSI真彩色代码"""
+        try:
+            rgb = [int(x * 255) for x in to_rgb(hex_color)]
+            return f"\033[38;2;{rgb[0]};{rgb[1]};{rgb[2]}m"
+        except ValueError as e:
+            warnings.warn(f"Invalid color value: {e}, falling back to cyan")
+            return "\033[96m"
+
+    def _resolve_color(self, index: int) -> str:
+        """解析当前应使用的颜色"""
+        if self._gradient_colors:
+            # 确保索引不超过颜色数
+            index = min(index, len(self._gradient_colors) - 1)
+            try:
+                return self._hex_to_ansi(self._gradient_colors[index])
+            except (IndexError, ValueError):
+                pass
+
+        return self._process_color_value(self.task.color)
+
+    def _process_color_value(self, color: Any) -> str:
+        """处理颜色输入格式"""
+        preset_map = {
+            "red": "\033[91m",
+            "green": "\033[92m",
+            "yellow": "\033[93m",
+            "cyan": "\033[96m",
+            "blue": "\033[94m",
+            "magenta": "\033[95m",
+            "white": "\033[97m",
+        }
+
+        if color in preset_map:
+            return preset_map[color]
+
+        try:
+            hex_color = to_hex(color)
+            return self._hex_to_ansi(hex_color)
+        except (ValueError, TypeError) as e:
+            warnings.warn(f"Color parsing failed: {e}, using cyan")
+            return preset_map["cyan"]
+
+    def _strip_ansi(self, text: str) -> str:
+        """移除所有ANSI转义序列"""
+        ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+        return ansi_escape.sub("", text)
+
+    def _format_bar(self, progress: float, width: int) -> str:
+        """格式化进度条显示"""
+        filled_list = ["▊", "█", "▓", "▒", "░", "#", "=", ">", "▌", "▍", "▎", "▏", "*"]
+        # filled = "░"
+        # filled = filled_list[2]  # 选择中间的填充字符
+        # filled = random.choice(filled_list)  # 随机选择填充字符
+        filled = filled_list[min(self.mark_num, len(filled_list) - 1)]  # 随机选择填充字符
+        empty = " "
+        # 为其他信息保留更多空间
+        max_width = max(10, width - 60)  # 至少保留10个字符的进度条
+        filled_length = int(round(max_width * progress))
+        return filled * filled_length + empty * (max_width - filled_length)
+
+    def update(self, advance: float = 1) -> None:
+        """更新进度"""
+        with self._lock:
+            current_time = time.time()
+            old_sample_time = current_time - self.speed_estimate_period
+
+            completed_start = self.task.completed
+            self.task.completed += advance
+            update_completed = self.task.completed - completed_start
+
+            # 更新速度采样
+            progress = self.task._progress
+
+            # 清理旧的采样数据
+            while progress and progress[0].timestamp < old_sample_time:
+                progress.popleft()
+
+            # 添加新采样点
+            if update_completed > 0:
+                progress.append(ProgressSample(current_time, update_completed))
+
+            # 检查是否完成
+            if self.task.total is not None and self.task.completed >= self.task.total and self.task.finished_time is None:
+                self.task.finished_time = self.task.elapsed
+                self.task.finished_speed = self.task.speed
+
+    def render(self) -> str:
+        """渲染进度条"""
+        with self._lock:
+            # 应该在锁保护下访问task对象
+            task = self.task
+
+            # 获取终端宽度
+            try:
+                term_width = self.bar_length or (shutil.get_terminal_size().columns if self._is_terminal else 80)
+            except (AttributeError, OSError):
+                term_width = 80  # 默认终端宽度
+
+            # 确保有效宽度不小于最低限制
+            effective_width = max(15, term_width - 40)
+            if effective_width < 10:
+                warnings.warn("Terminal width is too small for proper progress bar rendering.")
+                effective_width = 10  # 设置最低宽度限制
+
+            # 计算进度信息
+            progress = task.completed / task.total if task.total else 0
+            index = int(task.completed)
+            current_color = self._resolve_color(index) if self._gradient_colors else self._resolve_color(0)
+            reset_code = "\033[0m"
+
+            # 计算时间和速度信息
+            elapsed = task.elapsed or 0
+            remaining = task.time_remaining
+            speed = task.speed or 0
+
+            # 调整时间单位
+            if elapsed >= 3600:
+                elapsed_info = f"Elapsed: {elapsed / 3600:.1f}h"
+            elif elapsed >= 60:
+                elapsed_info = f"Elapsed: {elapsed / 60:.1f}m"
+            else:
+                elapsed_info = f"Elapsed: {elapsed:.1f}s"
+
+            time_info = f"ETA: {remaining:.1f}s" if task.total and remaining and remaining > 0 else elapsed_info
+
+            # 构建进度条视觉部分
+            bar = self._format_bar(progress, effective_width)
+
+            # 获取当前时间
+            current_time = time.strftime("%H:%M:%S", time.localtime())
+
+            # 组织显示文本
+            count_info = f"{int(task.completed)}/{int(task.total)}" if task.total else str(int(task.completed))
+            percent = f"{progress:.1%}" if task.total else ""
+            rate_info = f"{speed:.1f}it/s" if speed else ""
+
+            # 构建完整的进度条行
+            line = f"{current_time} {self.description} {current_color}[{bar}]{reset_code} {count_info} {percent} [{time_info} | {rate_info}]"
+
+            # 确保不超出终端宽度
+            if len(self._strip_ansi(line)) > term_width:
+                line = line[: term_width - 3] + "..."
+
+            return line
+
+    def refresh(self) -> None:
+        """刷新显示进度条"""
+        if not self._is_terminal and not self._is_jupyter:
+            return
+
+        with self._lock:
+            line = self.render()
+
+            # 根据环境选择不同的输出方式
+            if self._is_jupyter:
+                # Jupyter环境，使用换行模式
+                self._file.write(f"{line}\n")
+            elif self._is_terminal:
+                # 标准终端环境，覆盖同一行
+                self._file.write(f"\r{line}")
+            else:
+                # 非交互式环境，仅在完成时输出
+                if self.task.finished:
+                    self._file.write(f"{line}\n")
+
+            # 强制刷新输出
+            self._file.flush()
+
+    def __iter__(self):
+        """迭代器实现，支持进度显示"""
+        self.task.start()
+        self._last_update_time = time.time()
+
+        try:
+            # 迭代原始可迭代对象
+            for i, item in enumerate(self.iterable):
+                yield item
+
+                # 更新进度
+                self.update(1)
+
+                # 判断是否需要刷新显示
+                now = time.time()
+                should_refresh = (now - self._last_update_time >= self.update_interval) or (self.task.total and self.task.completed >= self.task.total)
+
+                if should_refresh:
+                    self.refresh()
+                    self._last_update_time = now
+
+        finally:
+            # 完成后进行清理
+            if self._is_terminal and not self._is_jupyter:
+                self._file.write("\n")
+                self._file.flush()
+
+    @classmethod
+    def gradient_color(cls, colors: List[str], n: int) -> List[str]:
+        """生成渐变色列表"""
+        cmap = LinearSegmentedColormap.from_list("gradient", colors)
+        return [to_hex(cmap(i)) for i in np.linspace(0, 1, n)]
+
+
+# 验证示例
+if __name__ == "__main__":
+    for _ in ColorProgressBar(range(100), description="Diverging:", cmap="diverging_1"):
+        # print("\rTesting...", end="")
+        time.sleep(0.1)
+
+    for _ in ColorProgressBar(range(100), description="Colorful:", cmap="colorful_1"):
+        time.sleep(0.1)
+
+    for _ in ColorProgressBar(range(100), description="Viridis:", cmap="viridis"):
+        time.sleep(0.1)
+
+    # 使用自定义渐变色
+    for _ in ColorProgressBar(range(50), description="Custom_cmap:", cmap=["#FF0000", "#0000FF"]):
+        time.sleep(0.1)
+
+    for _ in ColorProgressBar(range(50), description="Default:"):
+        time.sleep(0.1)
+
+    for _ in ColorProgressBar(range(50), description="Custom_color:", color="#FF00FF"):
+        time.sleep(0.1)
+
+    # 测试无法获取长度的迭代器
+    def infinite_generator():
+        i = 0
+        while True:
+            yield i
+            i += 1
+
+    # 限制为20个元素，但进度条不知道总长度
+    gen = infinite_generator()
+    for i, _ in enumerate(ColorProgressBar(gen, description="Unknown_length:")):
+        if i >= 20:
+            break
+        time.sleep(0.1)

{oafuncs-0.0.97.13/oafuncs/oa_tool → oafuncs-0.0.97.14/oafuncs/_script}/email.py

@@ -1,17 +1,19 @@
 #!/usr/bin/env python
 # coding=utf-8
-'''
+"""
 Author: Liu Kun && 16031215@qq.com
-Date: 2024-11-21 09:47:41
+Date: 2025-04-04 20:21:59
 LastEditors: Liu Kun && 16031215@qq.com
-LastEditTime: 2024-11-29 20:54:43
-FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\oa_tool\\email.py
-Description:  
+LastEditTime: 2025-04-04 20:21:59
+FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\_script\\email.py
+Description:
 EditPlatform: vscode
 ComputerInfo: XPS 15 9510
 SystemInfo: Windows 11
 Python Version: 3.12
-'''
+"""
+
+
 
 
 import random
@@ -22,29 +24,29 @@ from email.mime.text import MIMEText
 
 from rich import print
 
-__all__ = ['send']
+__all__ = ["send"]
 
 
 def _email_info():
     email_dict = {
-        'liukun0312@vip.qq.com': [4, 13, -10, 2, -10, 4, -7, -8, 8, -1, 3, -2, -11, -6, -9, -7],
-        '756866877@qq.com': [4, -2, -3, 13, 12, 8, -6, 9, -12, 13, -10, -12, -11, -12, -4, -11],
-        '99138763@qq.com': [0, 6, 12, 2, 9, 9, 4, -1, 11, -7, -12, 6, -11, -3, -5, -11],
-        '1031260@qq.com': [-1, -5, -9, 9, -3, 4, -8, -7, -12, -2, 0, -9, -11, -3, -7, -10],
+        "liukun0312@vip.qq.com": [4, 13, -10, 2, -10, 4, -7, -8, 8, -1, 3, -2, -11, -6, -9, -7],
+        "756866877@qq.com": [4, -2, -3, 13, 12, 8, -6, 9, -12, 13, -10, -12, -11, -12, -4, -11],
+        "99138763@qq.com": [0, 6, 12, 2, 9, 9, 4, -1, 11, -7, -12, 6, -11, -3, -5, -11],
+        "1031260@qq.com": [-1, -5, -9, 9, -3, 4, -8, -7, -12, -2, 0, -9, -11, -3, -7, -10],
     }
     keys = list(email_dict.keys())
-    choose_email = random.randint(0, len(keys)-1)
+    choose_email = random.randint(0, len(keys) - 1)
     msg_from = keys[choose_email]
     return msg_from, email_dict[msg_from]
 
 
 def _decode_password(password):
-    return ''.join([chr(i+109) for i in password])
+    return "".join([chr(i + 109) for i in password])
 
 
 def _send_message(title, content, msg_to):
     # 1. 连接邮箱服务器
-    con = smtplib.SMTP_SSL('smtp.qq.com', 465)
+    con = smtplib.SMTP_SSL("smtp.qq.com", 465)
 
     # 2. 登录邮箱
     msg_from, password = _email_info()
@@ -55,14 +57,14 @@ def _send_message(title, content, msg_to):
     msg = MIMEMultipart()
 
     # 设置邮件主题
-    subject = Header(title, 'utf-8').encode()
-    msg['Subject'] = subject
+    subject = Header(title, "utf-8").encode()
+    msg["Subject"] = subject
 
     # 设置邮件发送者
-    msg['From'] = msg_from
+    msg["From"] = msg_from
 
     # 设置邮件接受者
-    msg['To'] = msg_to
+    msg["To"] = msg_to
 
     # # 添加html内容
     # content = """
@@ -78,18 +80,18 @@ def _send_message(title, content, msg_to):
 
     # or
     # content = '发送内容'
-    msg.attach(MIMEText(content, 'plain', 'utf-8'))
+    msg.attach(MIMEText(content, "plain", "utf-8"))
 
     # 4.发送邮件
     con.sendmail(msg_from, msg_to, msg.as_string())
     con.quit()
 
-    print(f'已通过{msg_from}成功向{msg_to}发送邮件！')
-    print('发送内容为：\n{}\n\n'.format(content))
+    print(f"已通过{msg_from}成功向{msg_to}发送邮件！")
+    print("发送内容为：\n{}\n\n".format(content))
 
 
-def send(title='Title', content=None, send_to='16031215@qq.com'):
-    '''
+def send(title="Title", content=None, send_to="16031215@qq.com"):
+    """
     Description: 发送邮件
 
     Args:
@@ -102,7 +104,7 @@ def send(title='Title', content=None, send_to='16031215@qq.com'):
 
     Example:
         send(title='Title', content='Content', '123@qq.com')
-    '''
+    """
     if content is None:
         # 避免发送空邮件，或有人误调用
         return

oafuncs-0.0.97.14/oafuncs/_script/netcdf_merge.py

@@ -0,0 +1,107 @@
+import os
+from typing import List, Optional, Union
+from dask.diagnostics import ProgressBar
+import xarray as xr
+from oafuncs import pbar
+
+def merge_nc(file_list: Union[str, List[str]], var_name: Optional[Union[str, List[str]]] = None, dim_name: Optional[str] = None, target_filename: Optional[str] = None) -> None:
+    """
+    Description:
+        Merge variables from multiple NetCDF files along a specified dimension and write to a new file.
+        If var_name is a string, it is considered a single variable; if it is a list and has only one element, it is also a single variable;
+        If the list has more than one element, it is a multi-variable; if var_name is None, all variables are merged.
+
+    Parameters:
+        file_list: List of NetCDF file paths or a single file path as a string
+        var_name: Name of the variable to be extracted or a list of variable names, default is None, which means all variables are extracted
+        dim_name: Dimension name used for merging
+        target_filename: Target file name after merging
+
+    Example:
+        merge(file_list, var_name='u', dim_name='time', target_filename='merged.nc')
+        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')
+    """
+    
+    if target_filename is None:
+        target_filename = "merged.nc"
+
+    # 确保目标路径存在
+    target_dir = os.path.dirname(target_filename)
+    if target_dir and not os.path.exists(target_dir):
+        os.makedirs(target_dir)
+
+    if isinstance(file_list, str):
+        file_list = [file_list]
+
+    # 初始化变量名列表
+    if var_name is None:
+        with xr.open_dataset(file_list[0]) as ds:
+            var_names = list(ds.variables.keys())
+    elif isinstance(var_name, str):
+        var_names = [var_name]
+    elif isinstance(var_name, list):
+        var_names = var_name
+    else:
+        raise ValueError("var_name must be a string, a list of strings, or None")
+
+    # 初始化合并数据字典
+    merged_data = {}
+
+    for i, file in pbar(enumerate(file_list),description="Reading files", color="green",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:
+                    merged_data[var] = data_var.fillna(0)  # 用0填充NaN值
+
+    for var in pbar(merged_data, description="Merging variables", color="#9b45d1"):
+        if isinstance(merged_data[var], list):
+            merged_data[var] = xr.concat(merged_data[var], dim=dim_name).fillna(0)
+        # print(f"Variable '{var}' merged: min={merged_data[var].min().values:.3f}, max={merged_data[var].max().values:.3f}, mean={merged_data[var].mean().values:.3f}")
+
+    # 修改写入数据部分，支持压缩并设置基数和比例因子
+    # print("\nWriting data to file ...")
+    if os.path.exists(target_filename):
+        print("Warning: The target file already exists. Removing it ...")
+        os.remove(target_filename)
+
+    with xr.Dataset(merged_data) as merged_dataset:
+        encoding = {}
+        for var in merged_dataset.data_vars:
+            data = merged_dataset[var].values
+            # print(f"Variable '{var}' ready for writing: min={data.min():.3f}, max={data.max():.3f}, mean={data.mean():.3f}")
+            if data.dtype.kind in {"i", "u", "f"}:  # 仅对数值型数据进行压缩
+                data_range = data.max() - data.min()
+                if data_range > 0:  # 避免范围过小导致的精度问题
+                    scale_factor = data_range / (2**16 - 1)
+                    add_offset = data.min()
+                    encoding[var] = {
+                        "zlib": True,
+                        "complevel": 4,
+                        "dtype": "int16",
+                        "scale_factor": scale_factor,
+                        "add_offset": add_offset,
+                        "_FillValue": -32767,
+                    }
+                else:
+                    encoding[var] = {"zlib": True, "complevel": 4}  # 范围过小时禁用缩放
+            else:
+                encoding[var] = {"zlib": True, "complevel": 4}  # 非数值型数据不使用缩放
+
+        # 确保写入时不会因编码问题导致数据丢失
+        # merged_dataset.to_netcdf(target_filename, encoding=encoding)
+        delayed_write = merged_dataset.to_netcdf(target_filename, encoding=encoding, compute=False)
+        with ProgressBar():
+            delayed_write.compute()
+
+    print(f'\nFile "{target_filename}" has been successfully created.')
+
+
+# Example usage
+if __name__ == "__main__":
+    files_to_merge = ["file1.nc", "file2.nc", "file3.nc"]
+    output_path = "merged_output.nc"
+    merge_nc(files_to_merge, var_name=None, dim_name="time", target_filename=output_path)