oafuncs 0.0.97.4__py3-none-any.whl → 0.0.97.5__py3-none-any.whl

oafuncs/oa_file.py

@@ -17,9 +17,11 @@ import glob
 import os
 import re
 import shutil
+
+from ._script.replace_file_concent import replace_direct_content
 from rich import print
 
-__all__ = ["find_file", "link_file", "copy_file", "rename_file", "make_folder", "clear_folder", "remove_empty_folder", "remove", "file_size", "mean_size", "make_dir"]
+__all__ = ["find_file", "link_file", "copy_file", "rename_file", "make_folder", "clear_folder", "remove_empty_folder", "remove", "file_size", "mean_size", "make_dir", "replace_content"]
 
 
 # ** 查找文件，支持通配符
@@ -217,13 +219,13 @@ def make_dir(directory):
     """
     Description:
         Create a directory if it does not exist
-    
+
     Parameters:
         directory: The directory path to create
-    
+
     Returns:
         None
-        
+
     Example:
         make_dir(r"E:\\Data\\2024\\09\\17\\var1")
     """
@@ -355,7 +357,7 @@ def file_size(file_path, unit="KB"):
     if not os.path.exists(file_path):
         # return "文件不存在"
         # print(f"文件不存在: {file_path}\n返回0.0")
-        print(f'File does not exist: {file_path}\nReturn 0.0')
+        print(f"File does not exist: {file_path}\nReturn 0.0")
         return 0.0
 
     # 获取文件大小（字节）
@@ -378,25 +380,25 @@ def file_size(file_path, unit="KB"):
 
 
 # ** 计算文件夹下指定相关文件的平均大小
-def mean_size(parent_path,fname,max_num=None,unit="KB"):
+def mean_size(parent_path, fname, max_num=None, unit="KB"):
     """
     Description:
         Calculate the average size of the specified related files in the folder
-    
+
     Parameters:
         parent_path: The parent path where the files are located
         fname: The file name pattern to search for
         max_num: The maximum number of files to search for
         unit: The unit of the file size, default is "KB"
-    
+
     Returns:
         The average size
     """
     flist = find_file(parent_path, fname)
     if flist:
         if max_num:
-            flist = flist[:int(max_num)]
-        size_list = [file_size(f,unit) for f in flist if file_size(f,unit) > 0]
+            flist = flist[: int(max_num)]
+        size_list = [file_size(f, unit) for f in flist if file_size(f, unit) > 0]
         if size_list:
             return sum(size_list) / len(size_list)
         else:
@@ -405,6 +407,24 @@ def mean_size(parent_path,fname,max_num=None,unit="KB"):
         return 0.0
 
 
+def replace_content(source_file, content_dict, key_value=False, target_dir=None, new_name=None):
+    """
+    直接替换文件中的指定内容并保存到新路径
+
+    参数：
+    source_file: 源文件路径
+    target_dir: 目标目录路径
+    content_dict: 要替换的内容字典 {旧内容: 新内容}
+    key_value: 是否按键值对方式替换参数
+
+    返回:
+    bool: 替换是否成功
+    """
+    if target_dir is None:
+        target_dir = os.path.dirname(source_file)
+    replace_direct_content(source_file, target_dir, content_dict, key_value=key_value, new_name=new_name)
+
+
 if __name__ == "__main__":
     # newpath = make_folder('D:/Data/2024/09/17/', 'var1', clear=1)
     # print(newpath)

oafuncs/oa_tool/parallel.py

@@ -1,19 +1,40 @@
+#!/usr/bin/env python
+# coding=utf-8
+"""
+Author: Liu Kun && 16031215@qq.com
+Date: 2025-01-11 19:47:08
+LastEditors: Liu Kun && 16031215@qq.com
+LastEditTime: 2025-03-18 19:21:36
+FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\oa_tool\\parallel.py
+Description:
+EditPlatform: vscode
+ComputerInfo: XPS 15 9510
+SystemInfo: Windows 11
+Python Version: 3.12
+"""
+
+import contextlib
 import logging
 import multiprocessing as mp
+import os
+import platform
+import time
 from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed
 
+import psutil
+
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
-__all__ = ["ParallelExecutor"]
+__all__ = ["Simple_ParallelExecutor", "ParallelExecutor"]
 
 
-class ParallelExecutor:
+class Simple_ParallelExecutor:
     """
     A class for parallel execution of tasks using threads or processes.
 
     If mode is "process", the tasks are executed in separate processes.
     If mode is "thread", the tasks are executed in separate threads.
-    
+
     Parameters:
         mode (str): The execution mode. Supported values are "process" and "thread".
                     process ~ Must use top function to run, can't use in jupyter notebook
@@ -66,24 +87,476 @@ class ParallelExecutor:
         logging.info("Parallel execution completed.")
         return results
 
+
 def _compute_square(x):
     return x * x
 
-def _example():  
+
+def _example():
     def _compute_sum(a, b):
         return a + b
 
-    executor1 = ParallelExecutor(mode="process", max_workers=4)
+    executor1 = Simple_ParallelExecutor(mode="process", max_workers=4)
     params1 = [(i,) for i in range(10)]
     results1 = executor1.run(_compute_square, params1)
     print("Results (compute_square):", results1)
 
-    executor2 = ParallelExecutor(mode="thread", max_workers=2)
+    executor2 = Simple_ParallelExecutor(mode="thread", max_workers=2)
     params2 = [(1, 2), (3, 4), (5, 6)]
     results2 = executor2.run(_compute_sum, params2)
     print("Results (compute_sum):", results2)
 
 
+class ParallelExecutor:
+    """
+    自动优化的并行执行器，根据平台和任务特性自动选择最佳执行模式和工作线程/进程数量。
+
+    特性:
+    - 自动检测平台并选择最佳执行模式
+    - 动态调整工作线程/进程数量
+    - 针对Linux和Windows的特定优化
+    - 任务批处理功能以提高小任务的效率
+    - 自动故障转移机制
+    """
+
+    def __init__(self):
+        # 检测平台
+        self.platform = self._detect_platform()
+        # 自动选择最佳执行模式和工作线程/进程数量
+        self.mode, self.max_workers = self._determine_optimal_settings()
+        # 初始化执行器
+        self._executor = None
+        self.executor_class = ProcessPoolExecutor if self.mode == "process" else ThreadPoolExecutor
+        # 进程池重用策略
+        self.reuse_pool = self.mode == "process" and self.platform != "windows"
+
+        # 特定于平台的优化参数
+        self.mp_context = None
+        self.chunk_size = self._get_default_chunk_size()
+        self.timeout_per_task = 3600  # 默认任务超时时间（秒）
+        self.worker_init_func = None
+
+        # 针对Linux的特定优化
+        if self.platform == "linux":
+            self._setup_linux_optimizations()
+        # 针对Windows的特定优化
+        elif self.platform == "windows":
+            self._setup_windows_optimizations()
+
+        logging.info(f"Initialized {self.__class__.__name__} with mode={self.mode}, max_workers={self.max_workers} on {self.platform} platform")
+
+    def _detect_platform(self):
+        """检测当前运行的平台"""
+        system = platform.system().lower()
+        if system == "linux":
+            return "linux"
+        elif system == "windows":
+            return "windows"
+        elif system == "darwin":
+            return "macos"
+        else:
+            return "unknown"
+
+    def _determine_optimal_settings(self):
+        """确定最佳执行模式和工作线程/进程数量"""
+        mode = "process"  # 默认使用进程模式
+
+        # Linux平台优化
+        if self.platform == "linux":
+            # 在Linux上，根据之前的问题，我们优先使用进程模式
+            mode = "process"
+
+            # 检查是否在容器中运行（如Docker）
+            in_container = self._is_in_container()
+
+            # 获取物理和逻辑CPU核心数
+            physical_cores = psutil.cpu_count(logical=False) or 1
+            logical_cores = psutil.cpu_count(logical=True) or 1
+
+            # 获取系统内存信息
+            mem = psutil.virtual_memory()
+            # total_mem_gb = mem.total / (1024**3)
+            available_mem_gb = mem.available / (1024**3)
+
+            # 每个进程估计内存使用（根据应用程序特性调整）
+            est_mem_per_process_gb = 0.5
+
+            # 根据可用内存限制工作进程数
+            mem_limited_workers = max(1, int(available_mem_gb / est_mem_per_process_gb))
+
+            # 在容器环境中更保守一些
+            if in_container:
+                max_workers = min(physical_cores, mem_limited_workers, 4)
+            else:
+                max_workers = min(logical_cores, mem_limited_workers)
+
+        # Windows平台优化
+        elif self.platform == "windows":
+            # Windows上进程创建较快，线程和进程都可以考虑
+            # 但进程间通信开销大，所以对于小型任务，线程可能更高效
+            mode = "process"  # 默认也使用进程模式，因为通常更可靠
+
+            # Windows通常使用超线程，所以我们可以使用逻辑核心数
+            logical_cores = psutil.cpu_count(logical=True) or 1
+
+            # Windows建议使用更少的进程以减少开销
+            if logical_cores > 4:
+                max_workers = logical_cores - 1
+            else:
+                max_workers = max(1, logical_cores)
+
+        # macOS平台优化
+        elif self.platform == "macos":
+            mode = "process"
+            logical_cores = psutil.cpu_count(logical=True) or 1
+            max_workers = max(1, logical_cores - 1)
+
+        # 未知平台的保守设置
+        else:
+            mode = "process"
+            max_workers = max(1, (psutil.cpu_count(logical=True) or 2) - 1)
+
+        return mode, max_workers
+
+    def _is_in_container(self):
+        """检测是否在容器环境中运行"""
+        # 检查常见的容器环境指标
+        if os.path.exists("/.dockerenv"):
+            return True
+
+        try:
+            with open("/proc/1/cgroup", "rt") as f:
+                return any(("docker" in line or "kubepods" in line) for line in f)
+        except Exception:
+            pass
+
+        return False
+
+    def _setup_linux_optimizations(self):
+        """设置Linux特定的优化参数"""
+        try:
+            # 在Linux上，选择最适合的多进程上下文
+            # fork: 最快但可能会导致多线程程序出现问题
+            # spawn: 更安全但更慢
+            # forkserver: 中间解决方案
+
+            # 根据应用程序特性选择合适的上下文
+            self.mp_context = mp.get_context("fork")
+
+            # 设置进程初始化函数来设置CPU亲和性
+            self.worker_init_func = self._linux_worker_init
+
+        except Exception as e:
+            logging.warning(f"Failed to set Linux optimizations: {e}")
+            self.mp_context = None
+
+    def _setup_windows_optimizations(self):
+        """设置Windows特定的优化参数"""
+        # Windows优化参数
+        # 进程创建和启动开销在Windows上较高，因此增加每批的任务数
+        self.chunk_size = 10
+        # Windows通常不需要特殊的工作进程初始化
+        self.worker_init_func = None
+
+    def _linux_worker_init(self):
+        """Linux工作进程初始化函数"""
+        try:
+            # 获取当前进程
+            p = psutil.Process()
+
+            # 设置进程优先级为稍低于正常，以避免争抢重要系统资源
+            p.nice(10)
+
+            # 尝试设置CPU亲和性以提高缓存局部性
+            # 这里我们不设置特定的CPU核心，让系统调度，因为手动设置可能导致不平衡
+
+            # 设置进程I/O优先级
+            # 需要root权限，所以只是尝试一下
+            try:
+                os.system(f"ionice -c 2 -n 4 -p {os.getpid()} > /dev/null 2>&1")
+            except Exception:
+                pass
+
+        except Exception as e:
+            logging.debug(f"Worker initialization warning (non-critical): {e}")
+            pass  # 失败不中断程序运行
+
+    def _get_default_chunk_size(self):
+        """获取默认任务分块大小"""
+        if self.platform == "linux":
+            # Linux下进程创建较快，可以使用较小的块大小
+            return 5
+        elif self.platform == "windows":
+            # Windows下进程创建较慢，使用较大的块大小
+            return 10
+        else:
+            return 5
+
+    @property
+    def executor(self):
+        """懒加载并重用执行器"""
+        if self._executor is None and self.reuse_pool:
+            kwargs = {}
+            if self.mode == "process" and self.mp_context:
+                kwargs["mp_context"] = self.mp_context
+
+            if self.worker_init_func and self.mode == "process":
+                kwargs["initializer"] = self.worker_init_func
+
+            self._executor = self.executor_class(max_workers=self.max_workers, **kwargs)
+        return self._executor
+
+    @contextlib.contextmanager
+    def get_executor(self):
+        """获取执行器的上下文管理器"""
+        if self.reuse_pool and self._executor:
+            yield self._executor
+        else:
+            kwargs = {}
+            if self.mode == "process" and self.mp_context:
+                kwargs["mp_context"] = self.mp_context
+
+            if self.worker_init_func and self.mode == "process":
+                kwargs["initializer"] = self.worker_init_func
+
+            with self.executor_class(max_workers=self.max_workers, **kwargs) as executor:
+                yield executor
+
+    def run(self, func, param_list, chunk_size=None, fallback_on_failure=True):
+        """
+        并行执行函数
+
+        Args:
+            func (callable): 要执行的函数
+            param_list (list): 参数元组列表
+            chunk_size (int, optional): 任务分块大小，None表示使用默认值
+            fallback_on_failure (bool): 如果主执行模式失败，是否尝试其他模式
+
+        Returns:
+            list: 函数执行结果
+        """
+        if not callable(func):
+            raise ValueError("func must be callable.")
+        if not isinstance(param_list, list):
+            raise ValueError("param_list must be a list.")
+
+        # 空列表直接返回
+        if not param_list:
+            return []
+
+        # 使用默认分块大小或自定义大小
+        effective_chunk_size = chunk_size or self.chunk_size
+
+        # 任务分块处理
+        if effective_chunk_size and len(param_list) > effective_chunk_size * 2:
+            return self._run_chunked(func, param_list, effective_chunk_size)
+
+        try:
+            return self._execute(func, param_list)
+        except Exception as e:
+            if fallback_on_failure:
+                logging.warning(f"Execution failed with {self.mode} mode: {e}. Trying fallback...")
+                # 如果当前模式失败，尝试其他模式
+                old_mode = self.mode
+                self.mode = "thread" if old_mode == "process" else "process"
+                self.executor_class = ProcessPoolExecutor if self.mode == "process" else ThreadPoolExecutor
+                self._executor = None  # 重置执行器
+
+                try:
+                    results = self._execute(func, param_list)
+                    logging.info(f"Fallback to {self.mode} mode succeeded.")
+                    return results
+                except Exception as e2:
+                    logging.error(f"Fallback also failed: {e2}")
+                    # 恢复原始模式
+                    self.mode = old_mode
+                    self.executor_class = ProcessPoolExecutor if self.mode == "process" else ThreadPoolExecutor
+                    self._executor = None
+                    raise
+            else:
+                raise
+
+    def _execute(self, func, param_list):
+        """内部执行方法"""
+        results = [None] * len(param_list)
+        logging.info("Starting parallel execution in %s mode with %d workers.", self.mode, self.max_workers)
+
+        start_time = time.time()
+
+        with self.get_executor() as executor:
+            future_to_index = {executor.submit(func, *params): idx for idx, params in enumerate(param_list)}
+
+            for future in as_completed(future_to_index):
+                idx = future_to_index[future]
+                try:
+                    # 添加超时保护
+                    results[idx] = future.result(timeout=self.timeout_per_task)
+                except Exception as e:
+                    logging.error("Task %d failed with error: %s", idx, e)
+                    results[idx] = e
+
+        elapsed = time.time() - start_time
+        logging.info("Parallel execution completed in %.2f seconds.", elapsed)
+        return results
+
+    def _run_chunked(self, func, param_list, chunk_size):
+        """处理大量小任务的批处理执行"""
+
+        def process_chunk(chunk):
+            return [func(*params) for params in chunk]
+
+        # 将参数列表分成多个块
+        chunks = [param_list[i : i + chunk_size] for i in range(0, len(param_list), chunk_size)]
+
+        logging.info(f"Processing {len(param_list)} tasks in {len(chunks)} chunks of size ~{chunk_size}")
+
+        chunk_results = self._execute(process_chunk, [(chunk,) for chunk in chunks])
+
+        # 将块结果展平成单个结果列表
+        return [result for sublist in chunk_results if isinstance(sublist, list) for result in sublist]
+
+    def map(self, func, *iterables, timeout=None, chunk_size=None):
+        """
+        类似于内置map函数的并行版本
+
+        Args:
+            func: 要应用于每个元素的函数
+            *iterables: 一个或多个可迭代对象
+            timeout: 每个任务的超时时间
+            chunk_size: 任务分块大小
+
+        Returns:
+            生成器，产生的结果与输入顺序相同
+        """
+        # 将zip后的可迭代对象转换为参数元组列表
+        param_list = [(args,) for args in zip(*iterables)]
+
+        # 临时存储超时设置
+        original_timeout = self.timeout_per_task
+        if timeout:
+            self.timeout_per_task = timeout
+
+        try:
+            results = self.run(lambda x: func(x), param_list, chunk_size=chunk_size)
+            for r in results:
+                yield r
+        finally:
+            # 恢复原超时设置
+            self.timeout_per_task = original_timeout
+
+    def __del__(self):
+        """确保资源被正确释放"""
+        self.shutdown()
+
+    def shutdown(self):
+        """显式关闭执行器"""
+        if self._executor:
+            try:
+                self._executor.shutdown(wait=True)
+            except Exception:
+                pass
+            self._executor = None
+
+    def imap(self, func, *iterables, timeout=None, chunk_size=None):
+        """
+        类似concurrent.futures.Executor.map的接口，但返回迭代器
+        """
+        return self.map(func, *iterables, timeout=timeout, chunk_size=chunk_size)
+
+    def imap_unordered(self, func, *iterables, timeout=None, chunk_size=None):
+        """
+        类似multiprocessing.Pool.imap_unordered的接口，结果可能乱序返回
+        """
+        # 将zip后的可迭代对象转换为参数元组列表
+        param_list = [(args,) for args in zip(*iterables)]
+
+        # 空列表直接返回
+        if not param_list:
+            return
+
+        # 临时存储超时设置
+        original_timeout = self.timeout_per_task
+        if timeout:
+            self.timeout_per_task = timeout
+
+        try:
+            # 使用默认分块大小或自定义大小
+            effective_chunk_size = chunk_size or self.chunk_size
+
+            # 任务分块处理
+            if effective_chunk_size and len(param_list) > effective_chunk_size * 2:
+                chunks = [param_list[i : i + effective_chunk_size] for i in range(0, len(param_list), effective_chunk_size)]
+
+                with self.get_executor() as executor:
+                    futures = [executor.submit(self._process_chunk_for_imap, func, chunk) for chunk in chunks]
+
+                    for future in as_completed(futures):
+                        try:
+                            chunk_results = future.result(timeout=self.timeout_per_task)
+                            for result in chunk_results:
+                                yield result
+                        except Exception as e:
+                            logging.error(f"Chunk processing failed: {e}")
+            else:
+                with self.get_executor() as executor:
+                    futures = [executor.submit(func, *params) for params in param_list]
+
+                    for future in as_completed(futures):
+                        try:
+                            yield future.result(timeout=self.timeout_per_task)
+                        except Exception as e:
+                            logging.error(f"Task failed: {e}")
+                            yield e
+        finally:
+            # 恢复原超时设置
+            self.timeout_per_task = original_timeout
+
+    def _process_chunk_for_imap(self, func, chunk):
+        """处理imap_unordered的数据块"""
+        return [func(*params) for params in chunk]
+
+    def starmap(self, func, iterable, timeout=None, chunk_size=None):
+        """
+        类似于内置starmap函数的并行版本
+
+        Args:
+            func: 要应用于每个元素的函数
+            iterable: 可迭代对象，每个元素是函数参数的元组
+            timeout: 每个任务的超时时间
+            chunk_size: 任务分块大小
+
+        Returns:
+            生成器，产生结果
+        """
+
+        # 将每个元素转换为单参数函数调用
+        def wrapper(args):
+            return func(*args)
+
+        # 使用map实现
+        return self.map(wrapper, iterable, timeout=timeout, chunk_size=chunk_size)
+
+    def gather(self, funcs_and_args):
+        """
+        并行执行多个不同的函数，类似于asyncio.gather
+
+        Args:
+            funcs_and_args: 列表，每个元素是(func, args)元组，
+                            其中args是要传递给func的参数元组
+
+        Returns:
+            list: 函数执行结果，顺序与输入相同
+        """
+        if not isinstance(funcs_and_args, list):
+            raise ValueError("funcs_and_args must be a list of (func, args) tuples")
+
+        def wrapper(func_and_args):
+            func, args = func_and_args
+            return func(*args)
+
+        return self.run(wrapper, [(item,) for item in funcs_and_args])
+
+
 if __name__ == "__main__":
     _example()
     # 也可以不要装饰器，直接运行没啥问题，就是避免在ipynb中使用，最好使用ipynb，或者把这个函数放到一个独立的py文件中运行

{oafuncs-0.0.97.4.dist-info → oafuncs-0.0.97.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: oafuncs
-Version: 0.0.97.4
+Version: 0.0.97.5
 Summary: Oceanic and Atmospheric Functions
 Home-page: https://github.com/Industry-Pays/OAFuncs
 Author: Kun Liu
@@ -39,6 +39,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{oafuncs-0.0.97.4.dist-info → oafuncs-0.0.97.5.dist-info}/RECORD

@@ -2,13 +2,16 @@ oafuncs/__init__.py,sha256=GrygzGa_GDaWm3ERmxjNP1Pr7lrVx0MPOO_FcqkrvB8,1692
 oafuncs/oa_cmap.py,sha256=OfJ2DOBOGX5X1GihE6CPcTV8bAFdDqJSXV7vbqUgV9s,7552
 oafuncs/oa_data.py,sha256=32elvoBHibTunDXAK9ptQ-e-xrXxKM4GrPiMqWNv_lE,12169
 oafuncs/oa_draw.py,sha256=QypQp4vJIrbAyFddEVxd9K9Q4d85PRYqYQi9xDUmSZw,11150
-oafuncs/oa_file.py,sha256=ThMmJ6-pu7U6ssSh44Nd-cCxxJ1Mgd0izzKnDox9LM0,14572
+oafuncs/oa_file.py,sha256=pGtlIXCvzrmhZRkbL0juFOivge2GscfQWVIaz0AS6sQ,15262
 oafuncs/oa_help.py,sha256=loyzTbjU_0VpSIBvAEUA_tqxG8MVsO0xFE_2hgQ3zMw,4188
 oafuncs/oa_nc.py,sha256=7qxmx36ADkd8EGpTzAuFueMiZ2ewp5Sf-eAuRu5n7Xo,20115
 oafuncs/oa_python.py,sha256=Q-6UGGw_dJff7Ef8i87fsLPoGeHV5jBzfb-7HP4THR0,4018
 oafuncs/_data/OAFuncs.png,sha256=y1_x-mUP3gFjcy6m8FqfvQO_HgjzPhQKfXjnSHjslZE,3436152
 oafuncs/_data/hycom_3hourly.png,sha256=azt_uPcXtl_8CSKRLLPCIf5pPrcxMiOzvoFQnwb0zUo,12411415
+oafuncs/_script/auto_optimized_parallel_executor.py,sha256=4QaEk9AM-IneHm8KKSQ6MjSLNSaAWM4AQ-8OWXYdsaI,17300
+oafuncs/_script/parallel_example_usage.py,sha256=uLvE7iwkMn9Cyq6-wk5_RpbQk7PXM9d16-26lTknW9s,2646
 oafuncs/_script/plot_dataset.py,sha256=4PEMXI7NUgLMKwo-33y_AUrmUYS7BzmInCDyFalaZSk,13136
+oafuncs/_script/replace_file_concent.py,sha256=eCFZjnZcwyRvy6b4mmIfBna-kylSZTyJRfgXd6DdCjk,5982
 oafuncs/oa_down/User_Agent-list.txt,sha256=pazxSip8_lphEBOPHG902zmIBUg8sBKXgmqp_g6j_E4,661062
 oafuncs/oa_down/__init__.py,sha256=kRX5eTUCbAiz3zTaQM1501paOYS_3fizDN4Pa0mtNUA,585
 oafuncs/oa_down/hycom_3hourly.py,sha256=lCdbYQd7o_2jMgwmbrClNo5omrj5b5cnWnp6lnXMloQ,65307
@@ -28,10 +31,10 @@ oafuncs/oa_sign/ocean.py,sha256=xrW-rWD7xBWsB5PuCyEwQ1Q_RDKq2KCLz-LOONHgldU,5932
 oafuncs/oa_sign/scientific.py,sha256=a4JxOBgm9vzNZKpJ_GQIQf7cokkraV5nh23HGbmTYKw,5064
 oafuncs/oa_tool/__init__.py,sha256=WPrWq_vWWcUVQ32tsjA4jPQiV0LCxhxS0l4vmX43xDg,508
 oafuncs/oa_tool/email.py,sha256=4lJxV_KUzhxgLYfVwYTqp0qxRugD7fvsZkXDe5WkUKo,3052
-oafuncs/oa_tool/parallel.py,sha256=kYbiIFDB7EoxasmXGSomaEDVUsg9Rfvdgbw93lBOY7o,3770
+oafuncs/oa_tool/parallel.py,sha256=LBFWEKPcILVCbfSulETJE4wGPiOw1P_Fl9DzjYoCqgk,21844
 oafuncs/oa_tool/time.py,sha256=n8Ir5QFxJGZlEsOI3frxyQcN92wIvmS7-2SPQHYCg_c,486
-oafuncs-0.0.97.4.dist-info/LICENSE.txt,sha256=rMtLpVg8sKiSlwClfR9w_Dd_5WubTQgoOzE2PDFxzs4,1074
-oafuncs-0.0.97.4.dist-info/METADATA,sha256=MOPvUW8n0GkRBxhl-n8-SAGMfT9AZ4TqtD1XNqOZwxc,4158
-oafuncs-0.0.97.4.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-oafuncs-0.0.97.4.dist-info/top_level.txt,sha256=bgC35QkXbN4EmPHEveg_xGIZ5i9NNPYWqtJqaKqTPsQ,8
-oafuncs-0.0.97.4.dist-info/RECORD,,
+oafuncs-0.0.97.5.dist-info/licenses/LICENSE.txt,sha256=rMtLpVg8sKiSlwClfR9w_Dd_5WubTQgoOzE2PDFxzs4,1074
+oafuncs-0.0.97.5.dist-info/METADATA,sha256=defSpljPoBK_2UVFLEvAtoNmOl6ghws_g9vTw1lQH-o,4181
+oafuncs-0.0.97.5.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+oafuncs-0.0.97.5.dist-info/top_level.txt,sha256=bgC35QkXbN4EmPHEveg_xGIZ5i9NNPYWqtJqaKqTPsQ,8
+oafuncs-0.0.97.5.dist-info/RECORD,,

{oafuncs-0.0.97.4.dist-info → oafuncs-0.0.97.5.dist-info}/WHEEL

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