oafuncs 0.0.97.13__py3-none-any.whl → 0.0.97.14__py3-none-any.whl

oafuncs/_script/cprogressbar.py

@@ -1,34 +1,191 @@
-# progressbar.py
+import random
 import re
 import shutil
 import sys
+import threading
 import time
 import warnings
-from typing import Any, Iterable, List, Optional, Union
+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
+    # 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, prefix: str = "", color: Any = "cyan", cmap: Union[str, List[str]] = None, update_interval: float = 0.1, bar_length: int = None):
+    """彩色进度条，支持多种终端环境和颜色渐变效果"""
+
+    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.prefix = prefix
-        self.base_color = color
+        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._start_time = None
-        self._last_update = 0
-        self._count = len(iterable) if hasattr(iterable, "__len__") else None
+        # 线程安全锁
+        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._count else None
+        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支持）"""
@@ -39,15 +196,9 @@ class ColorProgressBar:
                 # 直接处理已经是colormap对象的情况
                 cmap = self.cmap
             else:
-                # 兼容不同版本的matplotlib
-                try:
-                    # 新版本matplotlib (>=3.6)
-                    cmap = matplotlib.colormaps[self.cmap]
-                except (AttributeError, KeyError):
-                    # 旧版本matplotlib
-                    cmap = matplotlib.cm.get_cmap(self.cmap)
-
-            return [to_hex(cmap(i)) for i in np.linspace(0, 1, self._count)]
+                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
@@ -63,13 +214,15 @@ class ColorProgressBar:
 
     def _resolve_color(self, index: int) -> str:
         """解析当前应使用的颜色"""
-        if self._gradient_colors and 0 <= index < len(self._gradient_colors):
+        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.base_color)
+        return self._process_color_value(self.task.color)
 
     def _process_color_value(self, color: Any) -> str:
         """处理颜色输入格式"""
@@ -78,6 +231,9 @@ class ColorProgressBar:
             "green": "\033[92m",
             "yellow": "\033[93m",
             "cyan": "\033[96m",
+            "blue": "\033[94m",
+            "magenta": "\033[95m",
+            "white": "\033[97m",
         }
 
         if color in preset_map:
@@ -97,79 +253,152 @@ class ColorProgressBar:
 
     def _format_bar(self, progress: float, width: int) -> str:
         """格式化进度条显示"""
-        filled = "▊"
+        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 _calculate_speed(self, index: int, elapsed: float) -> tuple:
-        """计算速率和剩余时间"""
-        # 防止除零错误
-        if index == 0 or elapsed < 1e-6:
-            return 0.0, 0.0
+    def update(self, advance: float = 1) -> None:
+        """更新进度"""
+        with self._lock:
+            current_time = time.time()
+            old_sample_time = current_time - self.speed_estimate_period
 
-        rate = index / max(elapsed, 1e-6)  # 确保分母不为零
-        remaining = (self._count - index) / rate if self._count else 0
-        return rate, remaining
+            completed_start = self.task.completed
+            self.task.completed += advance
+            update_completed = self.task.completed - completed_start
 
-    def __iter__(self):
-        self._start_time = time.time()
-        self._last_update = self._start_time
-        reset_code = "\033[0m"
+            # 更新速度采样
+            progress = self.task._progress
 
-        # 判断是否在终端环境中
-        is_terminal = hasattr(self._file, "isatty") and self._file.isatty()
+            # 清理旧的采样数据
+            while progress and progress[0].timestamp < old_sample_time:
+                progress.popleft()
 
-        try:
-            term_width = self.bar_length or (shutil.get_terminal_size().columns if is_terminal else 80)
-        except (AttributeError, OSError):
-            term_width = 80  # 默认终端宽度
+            # 添加新采样点
+            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
 
-        for i, item in enumerate(self.iterable):
-            now = time.time()
-            elapsed = now - self._start_time
-            yield item
+    def render(self) -> str:
+        """渲染进度条"""
+        with self._lock:
+            # 应该在锁保护下访问task对象
+            task = self.task
 
-            # 非终端环境或更新间隔未到时跳过更新
-            if not is_terminal or ((now - self._last_update) < self.update_interval and i + 1 != self._count):
-                continue
+            # 获取终端宽度
+            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"
 
-            progress = (i + 1) / self._count if self._count else 0
-            current_color = self._resolve_color(i) if self._gradient_colors else self._resolve_color(0)
+            time_info = f"ETA: {remaining:.1f}s" if task.total and remaining and remaining > 0 else elapsed_info
 
-            # 确保进度条至少有一个字符的宽度
-            effective_width = max(15, term_width - 40)  # 保留更多空间给信息显示
+            # 构建进度条视觉部分
             bar = self._format_bar(progress, effective_width)
 
-            rate, remaining = self._calculate_speed(i + 1, elapsed)
-
-            count_info = f"{i + 1}/{self._count}" if self._count else str(i + 1)
-            percent = f"{progress:.1%}" if self._count else ""
-            rate_info = f"{rate:.1f}it/s" if rate else ""
-            time_info = f"ETA: {remaining:.1f}s" if self._count and remaining > 0 else f"Elapsed: {elapsed:.1f}s"
+            # 获取当前时间
+            current_time = time.strftime("%H:%M:%S", time.localtime())
 
-            # 构建新的进度条行
-            line = f"{self.prefix}{current_color}[{bar}]{reset_code} {count_info} {percent} [{time_info} | {rate_info}]"
+            # 组织显示文本
+            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 ""
 
-            # 清除之前的行并强制光标回到行首
-            self._file.write("\r")
+            # 构建完整的进度条行
+            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] + "..."
 
-            # 输出并强制刷新
-            self._file.write(line)
-            self._file.flush()
-            self._last_update = now
+            return line
 
-        # 完成后添加换行符
-        if is_terminal:
-            self._file.write("\n")
+    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]:
         """生成渐变色列表"""
@@ -179,18 +408,24 @@ class ColorProgressBar:
 
 # 验证示例
 if __name__ == "__main__":
-    # 使用内置colormap示例
-    import oafuncs
+    for _ in ColorProgressBar(range(100), description="Diverging:", cmap="diverging_1"):
+        # print("\rTesting...", end="")
+        time.sleep(0.1)
 
-    cmap = oafuncs.oa_cmap.get("diverging_1")
-    for _ in ColorProgressBar(range(100), cmap=cmap, prefix="Diverging: "):
+    for _ in ColorProgressBar(range(100), description="Colorful:", cmap="colorful_1"):
         time.sleep(0.1)
 
-    for _ in ColorProgressBar(range(100), cmap="viridis", prefix="Viridis: "):
+    for _ in ColorProgressBar(range(100), description="Viridis:", cmap="viridis"):
         time.sleep(0.1)
 
     # 使用自定义渐变色
-    for _ in ColorProgressBar(range(50), cmap=["#FF0000", "#0000FF"], prefix="Custom: "):
+    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)
 
     # 测试无法获取长度的迭代器
@@ -202,7 +437,7 @@ if __name__ == "__main__":
 
     # 限制为20个元素，但进度条不知道总长度
     gen = infinite_generator()
-    for i, _ in enumerate(ColorProgressBar(gen, prefix="Unknown length: ")):
+    for i, _ in enumerate(ColorProgressBar(gen, description="Unknown_length:")):
         if i >= 20:
             break
         time.sleep(0.1)

oafuncs/{oa_tool → _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