OAFuncs 0.0.98.60__py3-none-any.whl

oafuncs/__init__.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+# coding=utf-8
+
+# 会导致OAFuncs直接导入所有函数，不符合模块化设计
+# from oafuncs.oa_s.oa_cmap import *
+# from oafuncs.oa_s.oa_data import *
+# from oafuncs.oa_s.oa_draw import *
+# from oafuncs.oa_s.oa_file import *
+# from oafuncs.oa_s.oa_help import *
+# from oafuncs.oa_s.oa_nc import *
+# from oafuncs.oa_s.oa_python import *
+
+# ------------------- 2024-12-13 12:31:06 -------------------
+# path: My_Funcs/OAFuncs/oafuncs/
+from .oa_cmap import *
+from .oa_data import *
+
+# ------------------- 2024-12-13 12:31:06 -------------------
+# path: My_Funcs/OAFuncs/oafuncs/oa_down/
+from .oa_down import *
+from .oa_draw import *
+from .oa_file import *
+from .oa_help import *
+
+# ------------------- 2024-12-13 12:31:06 -------------------
+# path: My_Funcs/OAFuncs/oafuncs/oa_model/
+from .oa_model import *
+from .oa_nc import *
+from .oa_python import *
+
+# ------------------- 2024-12-13 12:31:06 -------------------
+# path: My_Funcs/OAFuncs/oafuncs/oa_sign/
+from .oa_sign import *
+
+# ------------------- 2024-12-13 12:31:06 -------------------
+# path: My_Funcs/OAFuncs/oafuncs/oa_tool/
+from .oa_tool import *
+# ------------------- 2025-03-09 16:28:01 -------------------
+# path: My_Funcs/OAFuncs/oafuncs/_script/
+# from ._script import *
+# ------------------- 2025-03-16 15:56:01 -------------------
+from .oa_date import *
+# ------------------- 2025-03-27 16:56:57 -------------------
+from .oa_geo import *
+# ------------------- 2025-09-04 14:08:26 -------------------
+from .oa_linux import *
+# ------------------- 2025-09-14 12:30:00 -------------------

oafuncs/_script/cprogressbar.py

@@ -0,0 +1,468 @@
+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 = "green",
+        cmap: Union[str, List[str]] = None,
+        update_interval: float = 0.1,
+        bar_length: int = None,
+        speed_estimate_period: float = 30.0,
+        next_line: bool = False,
+    ):
+        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.next_line = next_line
+
+        # 线程安全锁
+        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
+
+        # 输出样式
+        # filled_list = ["▊", "█", "▓", "▒", "░", "#", "=", ">", "▌", "▍", "▎", "▏", "*"]
+        filled_list = ["█", "▓", "▒", "░", "#", "=", ">", "*"]
+        self.filled = random.choice(filled_list)
+
+    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 = self.filled
+        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)
+                # print(f'Terminal width: {term_width}')  # 调试输出
+            except (AttributeError, OSError):
+                term_width = 80  # 默认终端宽度
+
+            # 确保有效宽度不小于最低限制
+            # effective_width = max(15, term_width - 40)
+            effective_width = max(15, int(term_width * 0.6))  # 保留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:
+                # 标准终端环境，覆盖同一行
+                if self.next_line:
+                    self._file.write(f"\r{line}\n")
+                else:
+                    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 and not self.next_line:
+                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)]
+
+
+def cpbar(
+    iterable,
+    description="Working...",
+    total=None,
+    completed=0,
+    color="cyan",
+    cmap=None,
+    update_interval=0.1,
+    bar_length=None,
+    speed_estimate_period=30.0,
+    next_line=False,
+):
+    """便捷函数，返回 ColorProgressBar 对象"""
+    return ColorProgressBar(
+        iterable=iterable,
+        description=description,
+        total=total,
+        completed=completed,
+        color=color,
+        cmap=cmap,
+        update_interval=update_interval,
+        bar_length=bar_length,
+        speed_estimate_period=speed_estimate_period,
+        next_line=next_line,
+    )
+
+
+# 验证示例
+if __name__ == "__main__":
+    for _ in cpbar(range(20), description="Diverging:", cmap="diverging_1", next_line=True):
+        print("Processing...")
+        time.sleep(0.1)
+
+    for _ in ColorProgressBar(range(20), description="Viridis:", cmap="viridis"):
+        time.sleep(0.1)
+
+    # 使用自定义渐变色
+    for _ in ColorProgressBar(range(50), description="Custom_cmap:", cmap=["#FF0000", "#0000FF"]):
+        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/_script/data_interp.py

@@ -0,0 +1,96 @@
+from typing import List, Union
+
+import numpy as np
+from scipy.interpolate import griddata
+
+from oafuncs.oa_tool import PEx
+
+
+def _interp_single_worker(*args):
+    """
+    用于PEx并行的单slice插值worker。
+    参数: data_slice, origin_points, target_points, interpolation_method, target_shape
+    """
+    data_slice, origin_points, target_points, interpolation_method, target_shape = args
+    # 过滤掉包含 NaN 的点
+    valid_mask = ~np.isnan(data_slice.ravel())
+    valid_data = data_slice.ravel()[valid_mask]
+    valid_points = origin_points[valid_mask]
+
+    if len(valid_data) < 10:  # 如果有效数据太少，用均值填充
+        return np.full(target_shape, np.nanmean(data_slice))
+
+    # 使用有效数据进行插值
+    result = griddata(valid_points, valid_data, target_points, method=interpolation_method).reshape(target_shape)
+    # 对仍为 NaN 的点用最近邻填充
+    if np.isnan(result).any():
+        nn = griddata(valid_points, valid_data, target_points, method="nearest").reshape(target_shape)
+        result[np.isnan(result)] = nn[np.isnan(result)]
+
+    return result
+
+
+def interp_2d_func(target_x_coordinates: Union[np.ndarray, List[float]], target_y_coordinates: Union[np.ndarray, List[float]], source_x_coordinates: Union[np.ndarray, List[float]], source_y_coordinates: Union[np.ndarray, List[float]], source_data: np.ndarray, interpolation_method: str = "cubic") -> np.ndarray:
+    """
+    Perform 2D interpolation on the last two dimensions of a multi-dimensional array.
+
+    Args:
+        target_x_coordinates (Union[np.ndarray, List[float]]): Target grid's x-coordinates.
+        target_y_coordinates (Union[np.ndarray, List[float]]): Target grid's y-coordinates.
+        source_x_coordinates (Union[np.ndarray, List[float]]): Original grid's x-coordinates.
+        source_y_coordinates (Union[np.ndarray, List[float]]): Original grid's y-coordinates.
+        source_data (np.ndarray): Multi-dimensional array with the last two dimensions as spatial.
+        interpolation_method (str, optional): Interpolation method. Defaults to "cubic".
+            >>> optional: 'linear', 'nearest', 'cubic', 'quintic', etc.
+
+    Returns:
+        np.ndarray: Interpolated data array.
+
+    Raises:
+        ValueError: If input shapes are invalid.
+
+    Examples:
+        >>> target_x_coordinates = np.array([1, 2, 3])
+        >>> target_y_coordinates = np.array([4, 5, 6])
+        >>> source_x_coordinates = np.array([7, 8, 9])
+        >>> source_y_coordinates = np.array([10, 11, 12])
+        >>> source_data = np.random.rand(3, 3)
+        >>> result = interp_2d_func(target_x_coordinates, target_y_coordinates, source_x_coordinates, source_y_coordinates, source_data)
+        >>> print(result.shape)  # Expected output: (3, 3)
+    """
+    if len(target_y_coordinates.shape) == 1:
+        target_x_coordinates, target_y_coordinates = np.meshgrid(target_x_coordinates, target_y_coordinates)
+    if len(source_y_coordinates.shape) == 1:
+        source_x_coordinates, source_y_coordinates = np.meshgrid(source_x_coordinates, source_y_coordinates)
+
+    if source_x_coordinates.shape != source_data.shape[-2:] or source_y_coordinates.shape != source_data.shape[-2:]:
+        raise ValueError("[red]Shape of source_data does not match shape of source_x_coordinates or source_y_coordinates.[/red]")
+
+    target_points = np.column_stack((np.array(target_x_coordinates).ravel(), np.array(target_y_coordinates).ravel()))
+    origin_points = np.column_stack((np.array(source_x_coordinates).ravel(), np.array(source_y_coordinates).ravel()))
+
+    data_dims = len(source_data.shape)
+    # Ensure source_data is 4D for consistent processing (t, z, y, x)
+    if data_dims < 2:
+        raise ValueError(f"[red]Source data must have at least 2 dimensions, but got {data_dims}.[/red]")
+    elif data_dims > 4:
+        # Or handle cases with more than 4 dimensions if necessary
+        raise ValueError(f"Source data has {data_dims} dimensions, but this function currently supports only up to 4.")
+
+    # Reshape to 4D by adding leading dimensions of size 1 if needed
+    num_dims_to_add = 4 - data_dims
+    new_shape = (1,) * num_dims_to_add + source_data.shape
+    new_src_data = source_data.reshape(new_shape)
+
+    t, z, y, x = new_src_data.shape
+
+    params = []
+    target_shape = target_y_coordinates.shape
+    for t_index in range(t):
+        for z_index in range(z):
+            params.append((new_src_data[t_index, z_index], origin_points, target_points, interpolation_method, target_shape))
+
+    with PEx() as excutor:
+        result = excutor.run(_interp_single_worker, params)
+
+    return np.squeeze(np.array(result).reshape(t, z, *target_shape))

oafuncs/_script/email.py

@@ -0,0 +1,48 @@
+from rich import print
+
+
+
+def _send_message(msg_from, password, msg_to, title, content):
+    from email.header import Header
+    from email.mime.multipart import MIMEMultipart
+    from email.mime.text import MIMEText
+    import smtplib
+    # 1. 连接邮箱服务器
+    con = smtplib.SMTP_SSL("smtp.qq.com", 465)
+
+    # 2. 登录邮箱
+    # msg_from, password = _email_info()
+    # con.login(msg_from, _decode_password(password))
+    con.login(msg_from, password)
+
+    # 3. 准备数据
+    # 创建邮件对象
+    msg = MIMEMultipart()
+
+    # 设置邮件主题
+    subject = Header(title, "utf-8").encode()
+    msg["Subject"] = subject
+
+    # 设置邮件发送者
+    msg["From"] = msg_from
+
+    # 设置邮件接受者
+    msg["To"] = msg_to
+
+    # or
+    # content = '发送内容'
+    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))
+
+
+
+
+
+if __name__ == "__main__":
+    pass