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

oafuncs/_script/cprogressbar.py

@@ -1,45 +1,206 @@
-# progressbar.py
-import sys
+import random
+import re
 import shutil
+import sys
+import threading
 import time
 import warnings
-from typing import Iterable, Any, List, 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:
-    from matplotlib.colors import LinearSegmentedColormap, to_rgb, to_hex
-    from matplotlib.cm import get_cmap
+    # 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._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._start_time = None
-        self._last_update = 0
-        self._count = len(iterable) if hasattr(iterable, "__len__") else None
+        # 输出和渲染相关
         self._file = sys.stdout
-        self._gradient_colors = self._generate_gradient() if cmap else None
+        self._gradient_colors = self._generate_gradient() if cmap and self.task.total else None
+        self._last_update_time = 0
 
-    def _generate_gradient(self) -> List[str]:
+        # 检测终端环境
+        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:
-                # 正确获取Matplotlib内置colormap
-                cmap = get_cmap(self.cmap)
+                cmap = get_cmap(self.cmap)  # 使用oafuncs.oa_cmap.get获取内置colormap；也可获取原本自定义的colormap
 
-            return [to_hex(cmap(i)) for i in np.linspace(0, 1, self._count)]
+            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)}")
+            warnings.warn(f"Colormap generation failed: {str(e)}. cmap type: {type(self.cmap)}")
             return None
 
     def _hex_to_ansi(self, hex_color: str) -> str:
@@ -53,13 +214,15 @@ class ColorProgressBar:
 
     def _resolve_color(self, index: int) -> str:
         """解析当前应使用的颜色"""
-        if self._gradient_colors and 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:
+            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:
         """处理颜色输入格式"""
@@ -68,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:
@@ -80,57 +246,158 @@ class ColorProgressBar:
             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 = "▊"
+        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 = width - 50
+        # 为其他信息保留更多空间
+        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 / elapsed
-        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
+
+            # 清理旧的采样数据
+            while progress and progress[0].timestamp < old_sample_time:
+                progress.popleft()
+
+            # 添加新采样点
+            if update_completed > 0:
+                progress.append(ProgressSample(current_time, update_completed))
 
-        for i, item in enumerate(self.iterable):
-            now = time.time()
-            elapsed = now - self._start_time
-            yield item
+            # 检查是否完成
+            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
 
-            if (now - self._last_update) < self.update_interval and i + 1 != self._count:
-                continue
+    def render(self) -> str:
+        """渲染进度条"""
+        with self._lock:
+            # 应该在锁保护下访问task对象
+            task = self.task
 
-            term_width = self.bar_length or shutil.get_terminal_size().columns
-            progress = (i + 1) / self._count if self._count else 0
+            # 获取终端宽度
+            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"
 
-            current_color = self._resolve_color(i) if self._gradient_colors else self._resolve_color(0)
+            # 计算时间和速度信息
+            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"
 
-            bar = self._format_bar(progress, term_width)
-            rate, remaining = self._calculate_speed(i + 1, elapsed)
+            time_info = f"ETA: {remaining:.1f}s" if task.total and remaining and remaining > 0 else elapsed_info
 
-            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 else f"Elapsed: {elapsed:.1f}s"
+            # 构建进度条视觉部分
+            bar = self._format_bar(progress, effective_width)
 
-            line = (f"\r{self.prefix}{current_color}[{bar}]{reset_code} {count_info} {percent} [{time_info} | {rate_info}]").ljust(term_width)
+            # 获取当前时间
+            current_time = time.strftime("%H:%M:%S", time.localtime())
 
-            self._file.write(line)
+            # 组织显示文本
+            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()
-            self._last_update = now
 
-        self._file.write("\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]:
@@ -141,10 +408,36 @@ class ColorProgressBar:
 
 # 验证示例
 if __name__ == "__main__":
-    # 正确使用内置colormap
-    for _ in ColorProgressBar(range(100), cmap="viridis", prefix="Viridis: "):
-        time.sleep(0.05)
+    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), 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)
+
+    # 测试无法获取长度的迭代器
+    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/{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