re-common 10.0.29__py3-none-any.whl → 10.0.30__py3-none-any.whl

re_common/v2/baselibrary/tools/concurrency.py

@@ -0,0 +1,35 @@
+import asyncio
+from asyncio import Semaphore
+from typing import Awaitable, List, Iterable, Callable
+
+
+class AsyncTaskPool:
+    def __init__(self, max_workers: int = 10):
+        """
+
+        Args:
+            max_workers: 任务最大并发数
+        """
+        self.semaphore = Semaphore(max_workers)
+
+    async def _run_task(self, task: Awaitable):
+        async with self.semaphore:
+            return await task
+
+    async def run(self, tasks: List[Awaitable]):
+        return await asyncio.gather(*[self._run_task(task) for task in tasks])
+
+    async def map(self, fn: Callable[..., Awaitable], *iterables: Iterable):
+        tasks = [fn(*args) for args in zip(*iterables)]
+        return await self.run(tasks)
+
+
+if __name__ == "__main__":
+
+    async def test(x, y):
+        await asyncio.sleep(1)
+        print(x, y)
+        return x + y
+
+    result = asyncio.run(AsyncTaskPool(2).map(test, [1, 2, 3, 4], [5, 6, 7, 8]))
+    print(result)

re_common/v2/baselibrary/tools/hdfs_base_processor.py

@@ -0,0 +1,195 @@
+import abc
+import asyncio
+from concurrent.futures import ProcessPoolExecutor
+import gzip
+
+import multiprocessing
+from pathlib import Path
+
+from io import BytesIO
+import time
+from typing import Awaitable, Callable, Any, Generator, List, Literal, Union
+
+from hdfs import InsecureClient
+
+
+from re_common.v2.baselibrary.tools.resume_tracker import ResumeTracker
+
+
+_pool = None
+
+
+class HDFSBaseProcessor(abc.ABC):
+    def __init__(
+        self,
+        hdfs_dir: str,
+        hdfs_url: str = "http://VIP-DC-MASTER-2:9870",
+        hdfs_user: str = "root",
+        db_path: Union[str, Path] = "processed_files.db",
+        concurrency: int = 50,
+        batch_size: int = 50,
+        encoding: str = "utf-8",
+        read_mode: Literal["all", "stream"] = "all",
+        retries: int = 3,
+        pool_factory: Callable[[], Awaitable[Any]] = None,
+        max_processes: int = None,  # 添加多进程支持
+        result_dir: str = None,
+    ):
+        self.hdfs_dir = hdfs_dir
+        self.hdfs_url = hdfs_url
+        self.hdfs_user = hdfs_user
+        self.tracker = ResumeTracker(db_path)
+        self.concurrency = concurrency
+        self.batch_size = batch_size
+        self.encoding = encoding
+        self.read_mode = read_mode
+        self.retries = retries
+        self.result_dir = result_dir
+        self.pool_factory = pool_factory
+        self.max_processes = max_processes or max(multiprocessing.cpu_count() - 1, 1)  # 默认使用CPU核心数-1
+        self._client = None
+
+        self.tracker.init_db()
+
+    @property
+    def client(self):
+        if self._client is None:
+            self._client = InsecureClient(self.hdfs_url, user=self.hdfs_user)
+        return self._client
+
+    async def _get_pool(self):
+        if self.pool_factory is None:
+            return None
+        global _pool
+        if _pool is None:
+            _pool = await self.pool_factory()
+        return _pool
+
+    def _list_gz_files(self) -> List[str]:
+        """列出 HDFS 目录中的所有 gzip 文件"""
+        return [
+            f"{self.hdfs_dir}/{file[0]}"
+            for file in self.client.list(self.hdfs_dir, status=True)
+            if file[0].endswith(".gz")
+        ]
+
+    def _count_total_lines(self, gz_file_path: str) -> int:
+        with self.client.read(gz_file_path) as hdfs_file:
+            with gzip.GzipFile(fileobj=hdfs_file) as gz:
+                return sum(1 for _ in gz)
+
+    def _batch_read_gz_stream(self, gz_file_path: str) -> Generator[List[str], Any, None]:
+        """流式读取gz文件，分批yield返回"""
+        with self.client.read(gz_file_path) as hdfs_file:
+            with gzip.GzipFile(fileobj=hdfs_file) as gz:
+                while True:
+                    lines = []
+                    for _ in range(self.batch_size):
+                        try:
+                            line = next(gz)
+                            if line.strip():  # 移除空行
+                                lines.append(line.decode(self.encoding))  # 解码
+                        except StopIteration:  # 文件已读完
+                            break
+                    if not lines:
+                        break
+                    yield lines
+
+    def _batch_read_gz_all(self, gz_file_path: str) -> List[List[str]]:
+        """一次读取gz文件全部内容，二维数组批量返回"""
+        with self.client.read(gz_file_path) as reader:  # 以二进制模式读取
+            compressed_data = reader.read()  # 读取压缩数据
+            with gzip.GzipFile(fileobj=BytesIO(compressed_data)) as gz_file:  # 解压缩
+                content = gz_file.read().decode(self.encoding)  # 解码为字符串
+                print(f"文件读取成功: {gz_file_path}")
+                lines = [i for i in content.split("\n") if i.strip()]
+                batch_lines = [lines[i : i + self.batch_size] for i in range(0, len(lines), self.batch_size)]
+                return batch_lines
+
+    def _batch_read_gz(self, gz_file_path: str):
+        # 这里根据不同的配置选用不同的读取文件的方法
+        if self.read_mode == "stream":
+            return self._batch_read_gz_stream(gz_file_path)
+        else:
+            return self._batch_read_gz_all(gz_file_path)
+
+    def _generate_write_data(self, results):
+        for res in results:
+            yield str(res) + "\n"
+
+    def _print_progress(self, file_path, processed_lines, total_lines, start_time, processing_start_time):
+        elapsed_time = time.perf_counter() - start_time  # 已用时间
+        processing_time = time.perf_counter() - processing_start_time  # 本次处理时间
+        avg_processing_time = (
+            (elapsed_time * 1000) / processed_lines if processed_lines > 0 else float("inf")
+        )  # 平均每条数据的处理时间（毫秒）
+        # 估算剩余时间
+        remaining_time = (
+            ((avg_processing_time / 1000) * (total_lines - processed_lines)) if processed_lines > 0 else float("inf")
+        )
+        # 显示进度信息
+        print(
+            f"文件: {file_path} 总进度: {processed_lines}/{total_lines} 行 | "
+            f"已用时间: {elapsed_time:.2f}秒 | 本次处理时间: {processing_time:.2f}秒 | "
+            f"预估剩余时间: {remaining_time:.2f}秒 | 平均每条处理时间: {avg_processing_time:.2f}毫秒"
+        )
+
+    def _print_final_progress(self, file_path, processed_lines, total_lines, start_time):
+        final_elapsed_time = time.perf_counter() - start_time  # 最终已用时间
+        print(
+            f"文件: {file_path} 处理完成 | 总进度: {processed_lines}/{total_lines} 行 | "
+            f"总已用时间: {final_elapsed_time:.2f}秒 | "
+            f"平均每条处理时间: {(final_elapsed_time * 1000) / processed_lines:.2f}毫秒"
+            if processed_lines > 0
+            else "处理无数据"
+        )
+
+    @abc.abstractmethod
+    async def _process_file(self, hdfs_file_path, process_func):
+        pass
+
+    async def _retry_process_file(self, hdfs_file_path, process_func):
+        """带重试机制的文件处理"""
+        retry_count = 0
+        while retry_count < self.retries:
+            try:
+                if self.tracker.is_processed(hdfs_file_path):
+                    print(f"跳过已处理文件: {hdfs_file_path}")
+                    return True
+                await self._process_file(hdfs_file_path, process_func)
+                self.tracker.mark_processed(hdfs_file_path)  # 标记文件已处理
+                return True  # 成功处理后退出
+            except Exception as e:
+                retry_count += 1
+                print(f"处理文件 {hdfs_file_path} 时发生错误: {e}，正在重试 {retry_count}/{self.retries}")
+                await asyncio.sleep(2**retry_count)
+        print(f"处理文件 {hdfs_file_path} 失败，达到重试上限")
+        return False
+
+    def _process_file_wrapper(self, args):
+        """为多进程执行准备的同步包装函数"""
+        hdfs_file_path, process_func = args
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(self._retry_process_file(hdfs_file_path, process_func))
+
+    async def _run_multi_process(self, gz_files, process_func):
+        """多进程并发运行文件处理任务"""
+        args_list = [(file_path, process_func) for file_path in gz_files]
+        with ProcessPoolExecutor(max_workers=self.max_processes) as executor:
+            # return executor.map(self._process_file_wrapper, args_list)
+            loop = asyncio.get_running_loop()
+            self._client = None  # 避免连接对象无法序列化导致卡死
+            tasks = [loop.run_in_executor(executor, self._process_file_wrapper, args) for args in args_list]
+            results = await asyncio.gather(*tasks)
+
+        if all(results):
+            # 处理完成后清理断点记录
+            self.tracker.clear_processed_items()
+            print(f"已清空断点记录: {self.tracker.db_path}")
+            return results
+        else:
+            raise Exception("部分或全部文件处理失败")
+
+    @abc.abstractmethod
+    async def map(self, process_func: Callable[[Any, Any], Awaitable[Any]]) -> None:
+        pass

re_common/v2/baselibrary/tools/hdfs_bulk_processor.py

@@ -0,0 +1,67 @@
+from pathlib import Path
+import time
+from typing import Any, Awaitable, Callable, List
+from re_common.v2.baselibrary.tools.concurrency import AsyncTaskPool
+from re_common.v2.baselibrary.tools.hdfs_base_processor import HDFSBaseProcessor
+
+
+class HDFSBulkProcessor(HDFSBaseProcessor):
+    def _flat_map(self, results):
+        # return itertools.chain.from_iterable(chunked_results)
+        for res in results:
+            if isinstance(res, list):
+                yield from res
+            else:
+                yield res
+
+    async def _process_file(self, hdfs_file_path, process_func):
+        start_time = time.perf_counter()
+        total_lines = self._count_total_lines(hdfs_file_path)
+        processed_lines = 0
+        pool = await self._get_pool()
+
+        tasks = []
+        for lines in self._batch_read_gz(hdfs_file_path):
+            # 处理读取到的批次数据
+            if lines:
+                tasks.append(process_func(lines, pool))  # 将批次数据传递给处理函数并收集任务
+                processed_lines += len(lines)  # 更新已处理行数
+        results = await AsyncTaskPool(self.concurrency).run(tasks)
+
+        if self.result_dir is not None:
+            self.client.write(
+                self.result_dir.rstrip("/") + f"/{Path(hdfs_file_path).stem}",
+                data=self._generate_write_data(self._flat_map(results)),
+                overwrite=True,
+                encoding=self.encoding,
+            )
+
+        # 最终进度显示
+        self._print_final_progress(hdfs_file_path, processed_lines, total_lines, start_time)
+
+    async def map(self, process_func: Callable[[List[str], Any], Awaitable[Any]]) -> None:
+        gz_files = self._list_gz_files()
+        await self._run_multi_process(gz_files, process_func)
+
+
+# async def test_func(lines: List[str], pool):
+#     pass
+
+
+# async def main():
+#     processor = HDFSBulkProcessor(
+#         "/xx/xx",
+#         db_path=Path(__file__).parent / "test_bulk.db",
+#         concurrency=200,
+#         batch_size=1000,
+#         pool_factory=get_pool,
+#         max_processes=2,
+#         result_dir="/xx/xx_res",
+#     )
+#     # processor.tracker.mark_many_processed(f"/xx/xx/part-{num:05d}.gz" for num in range(0, 6000))
+
+#     await processor.map(test_func)
+
+
+# if __name__ == "__main__":
+#     asyncio.run(main())

re_common/v2/baselibrary/tools/hdfs_line_processor.py

@@ -0,0 +1,74 @@
+import asyncio
+
+from pathlib import Path
+import time
+from typing import Any, Awaitable, Callable
+from re_common.v2.baselibrary.tools.concurrency import AsyncTaskPool
+from re_common.v2.baselibrary.tools.hdfs_base_processor import HDFSBaseProcessor
+
+
+class HDFSLineProcessor(HDFSBaseProcessor):
+    async def _process_data(self, data, process_func, pool):
+        """处理数据并执行处理函数"""
+        retry_count = 0
+        while retry_count < self.retries:
+            try:
+                return await process_func(data, pool)  # 成功处理后退出
+            except Exception as e:
+                retry_count += 1
+                print(f"处理数据时发生错误: {e}, 正在重试 {retry_count}/{self.retries}, data: {data}")
+                await asyncio.sleep(2**retry_count)
+        raise Exception(f"处理数据失败, 达到重试上限, data: {data}")
+
+    async def _process_file(self, hdfs_file_path, process_func):
+        """处理单个 gz 文件"""
+        start_time = time.perf_counter()
+        total_lines = self._count_total_lines(hdfs_file_path)
+        processed_lines = 0
+        pool = await self._get_pool()
+        results = []
+
+        for lines in self._batch_read_gz(hdfs_file_path):
+            processing_start_time = time.perf_counter()  # 记录本批处理开始时间
+
+            tasks = [self._process_data(line, process_func, pool) for line in lines]
+            results.extend(await AsyncTaskPool(self.concurrency).run(tasks))
+
+            processed_lines += len(lines)
+
+            self._print_progress(hdfs_file_path, processed_lines, total_lines, start_time, processing_start_time)
+
+        if self.result_dir is not None:
+            self.client.write(
+                self.result_dir.rstrip("/") + f"/{Path(hdfs_file_path).stem}",
+                data=self._generate_write_data(results),
+                overwrite=True,
+                encoding=self.encoding,
+            )
+
+        # 最终进度显示
+        self._print_final_progress(hdfs_file_path, processed_lines, total_lines, start_time)
+
+    async def map(self, process_func: Callable[[str, Any], Awaitable[Any]]) -> None:
+        gz_files = self._list_gz_files()
+        await self._run_multi_process(gz_files, process_func)
+
+
+# async def test_func(line: str, pool):
+#     pass
+
+
+# async def main():
+#     await HDFSLineProcessor(
+#         "/xx/xx",
+#         db_path=Path(__file__).parent / "test.db",
+#         concurrency=200,
+#         batch_size=1000,
+#         pool_factory=get_pool,
+#         max_processes=2,
+#         result_dir="/xx/xx_res",
+#     ).map(test_func)
+
+
+# if __name__ == "__main__":
+#     asyncio.run(main())

re_common/v2/baselibrary/tools/resume_tracker.py

@@ -0,0 +1,94 @@
+import logging
+from pathlib import Path
+import sqlite3
+from typing import Iterable, List, Literal, Union
+
+logger = logging.getLogger(__name__)
+
+
+class ResumeTracker:
+    def __init__(
+        self,
+        db_path: Union[str, Path] = "processed.db",
+        timeout: float = 10.0,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None = "DEFERRED",
+    ):
+        self.db_path = Path(db_path)
+        self.timeout = timeout
+        self.isolation_level = isolation_level
+        self.init_db()
+
+    def _get_connection(self) -> sqlite3.Connection:
+        """创建数据库连接"""
+        return sqlite3.connect(self.db_path, timeout=self.timeout, isolation_level=self.isolation_level)
+
+    def init_db(self):
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS processed_items (
+                        item_key TEXT PRIMARY KEY
+                    )
+                    """)
+            conn.commit()
+
+    def is_processed(self, item_key: str) -> bool:
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT 1 FROM processed_items WHERE item_key = ?",
+                (item_key,),
+            )
+            return cursor.fetchone() is not None
+
+    def mark_processed(self, item_key: str):
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT OR IGNORE INTO processed_items (item_key) VALUES (?)",
+                (item_key,),
+            )
+            conn.commit()
+
+    def mark_many_processed(self, item_keys: Iterable[str]):
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.executemany(
+                "INSERT OR IGNORE INTO processed_items (item_key) VALUES (?)",
+                [(key,) for key in item_keys],
+            )
+            conn.commit()
+
+    def get_processed_count(self) -> int:
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT COUNT(*) FROM processed_items")
+            return cursor.fetchone()[0]
+
+    def get_processed_items(self) -> List[str]:
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT item_key FROM processed_items")
+            return [row[0] for row in cursor.fetchall()]
+
+    def clear_processed_items(self):
+        with self._get_connection() as conn:
+            conn.execute("DELETE FROM processed_items")
+            logger.info("Cleared all processed items")
+
+
+if __name__ == "__main__":
+    tracker = ResumeTracker()
+    # 测试标记功能
+    tracker.mark_processed("test_key")
+    print(f"Is 'test_key' processed? {tracker.is_processed('test_key')}")
+
+    # 批量处理示例
+    test_keys = [f"key_{i}" for i in range(1, 10000)]
+    tracker.mark_many_processed(test_keys)
+
+    # 显示处理计数
+    print(f"Total processed items: {tracker.get_processed_count()}")
+
+    # 清理测试数据
+    tracker.clear_processed_items()

re_common/v2/baselibrary/utils/db.py

@@ -33,6 +33,12 @@ DB_CONFIG1 = {
     'echo': False,  # 打印SQL语句
 }
 
+async def get_pool_only(_DB_CONFIG: dict = None):
+    global DB_CONFIG
+    if _DB_CONFIG is not None:
+        DB_CONFIG = _DB_CONFIG
+    pool: Pool = await aiomysql.create_pool(**DB_CONFIG)
+    return pool
 
 @asynccontextmanager
 async def get_db_pool(_DB_CONFIG: dict = None):

{re_common-10.0.29.dist-info → re_common-10.0.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: re_common
-Version: 10.0.29
+Version: 10.0.30
 Summary: a library about all python projects
 Home-page: https://gitee.com/xujiangios/re-common
 Author: vic
@@ -11,6 +11,14 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
 
 
     这是一个基础类，依赖很多的第三方包，是一个用得到的第三方库的封装，可以在此基础上迅速构建项目

{re_common-10.0.29.dist-info → re_common-10.0.30.dist-info}/RECORD

@@ -176,10 +176,15 @@ re_common/v2/baselibrary/s3object/baseboto3.py,sha256=mXuIFx99pnrPGQ4LJCZwlN1HLb
 re_common/v2/baselibrary/tools/WeChatRobot.py,sha256=sKBt2gPsfj0gzV6KaLSAhIhL-j3qNfHfqE-lII1LVwM,3537
 re_common/v2/baselibrary/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 re_common/v2/baselibrary/tools/ac_ahocorasick.py,sha256=c63y5RtKVLD37nyPCnBqfNygwRj4gTQqyIdDOrC65G0,2847
+re_common/v2/baselibrary/tools/concurrency.py,sha256=ctKBoeEbq1SGmhPp7oVR_QSXTKVAGLMByAHQKI6dAqU,981
 re_common/v2/baselibrary/tools/dict_tools.py,sha256=eSMwPTLp3oSjuviC_wlXg0I-dnkkmZfUfCRLX5djWV8,1365
 re_common/v2/baselibrary/tools/dolphinscheduler.py,sha256=1m7UGYDiuvJUCI6ik6CGM2fO8U5XteJzn55VRbwB9ts,7978
+re_common/v2/baselibrary/tools/hdfs_base_processor.py,sha256=WVYBwQ3gUm5jrDV_Ar9Rv0VwJCMODkGByY19HP6fZCA,8405
+re_common/v2/baselibrary/tools/hdfs_bulk_processor.py,sha256=8FjuZbcBXC_27zEQonLKvb0fMGwcIH9MPRTOmdMAuLU,2396
 re_common/v2/baselibrary/tools/hdfs_data_processer.py,sha256=g0DaNjXM1hIUblFQ6YBwnwEBKIXn48X8Y9Eiok4dVlQ,14824
+re_common/v2/baselibrary/tools/hdfs_line_processor.py,sha256=h1J_mOPoNvsjw7zYMsD7rr0Q6bXvVzo9tRJZVAbei1s,2732
 re_common/v2/baselibrary/tools/list_tools.py,sha256=1NxGVM4EytSXh4IGAEfZQnvq0Ev-UOF-PGZBg2EQbOg,2132
+re_common/v2/baselibrary/tools/resume_tracker.py,sha256=h3WyeIX0L2Q-O9AkCvKWJg48HP8Z8qILTowXzbRrB7c,3246
 re_common/v2/baselibrary/tools/search_hash_tools.py,sha256=2ENLtZE8opRsfkwRtTNMzITmpTsjO7wZ1ZkfkqpOH9U,1937
 re_common/v2/baselibrary/tools/text_matcher.py,sha256=cPMoFxaA0-ce3tLRxVSs8_3pTYS1oVIHDnNy_AlPU-4,10756
 re_common/v2/baselibrary/tools/unionfind_tools.py,sha256=VYHZZPXwBYljsm7TjV1B6iCgDn3O3btzNf9hMvQySVU,2965
@@ -197,7 +202,7 @@ re_common/v2/baselibrary/utils/basedict.py,sha256=sH3_RZ8u4649-jX2V1uKNNkjJVUijZ
 re_common/v2/baselibrary/utils/basehdfs.py,sha256=TPwFct_-UrmO1KCbo4gpV77rsnlCQDumNBbQKL0ZI9o,5953
 re_common/v2/baselibrary/utils/basepika.py,sha256=ifOb3UsGj79k40aD9UK6-5BMPw43ZAo0SO3AYD4q4vw,7332
 re_common/v2/baselibrary/utils/basetime.py,sha256=b7U_ho6nE3fjYBxSkdMHXUOd3ClH6KkW_7p7l2Gs4gA,3038
-re_common/v2/baselibrary/utils/db.py,sha256=ouDagXqqY9h4ucK4LDGrYVY-31rOiBQFxXLIlio9AJA,2297
+re_common/v2/baselibrary/utils/db.py,sha256=ceXTLGI0JfZQm06gl-hnQww6Lw4IuwkgeehYFo7bVlA,2509
 re_common/v2/baselibrary/utils/json_cls.py,sha256=M93piYtmgm_wP8E57culTrd_AhHLoGg6PqeAJYdW2SM,438
 re_common/v2/baselibrary/utils/mq.py,sha256=UHpO8iNIHs91Tgp-BgnSUpZwjWquxrGLdpr3FMMv2zw,2858
 re_common/v2/baselibrary/utils/n_ary_expression_tree.py,sha256=-05kO6G2Rth7CEK-5lfFrthFZ1Q0-0a7cni7mWZ-2gg,9172
@@ -231,8 +236,8 @@ re_common/vip/title/transform/TransformRegulationTitleToZt.py,sha256=LKRdIsWKues
 re_common/vip/title/transform/TransformStandardTitleToZt.py,sha256=-fCKAbSBzXVyQDCE61CalvR9E_QzQMA08QOO_NePFNI,5563
 re_common/vip/title/transform/TransformThesisTitleToZt.py,sha256=QS-uV0cQrpUFAcKucuJQ9Ue2VRQH-inmfn_X3IplfRo,5488
 re_common/vip/title/transform/__init__.py,sha256=m83-CWyRq_VHPYHaALEQlmXrkTdrZ3e4B_kCfBYE-uc,239
-re_common-10.0.29.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-re_common-10.0.29.dist-info/METADATA,sha256=eGXr-ItmT5GBm9Q5Powp842rq_7QWs-wEJsyNKKB6HM,582
-re_common-10.0.29.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-re_common-10.0.29.dist-info/top_level.txt,sha256=_H9H23zoLIalm1AIY_KYTVh_H0ZnmjxQIxsvXtLv45o,10
-re_common-10.0.29.dist-info/RECORD,,
+re_common-10.0.30.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+re_common-10.0.30.dist-info/METADATA,sha256=DiZvXFGwxsVgDiegqZsCWgUpx1r-KZg51ajXGUso-E4,764
+re_common-10.0.30.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+re_common-10.0.30.dist-info/top_level.txt,sha256=_H9H23zoLIalm1AIY_KYTVh_H0ZnmjxQIxsvXtLv45o,10
+re_common-10.0.30.dist-info/RECORD,,

{re_common-10.0.29.dist-info → re_common-10.0.30.dist-info}/WHEEL

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