tketool.pipeline 1.3.5__tar.gz

tketool_pipeline-1.3.5/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: tketool.pipeline
+Version: 1.3.5
+Summary: Stage-based processing pipeline and injection decorators for tketool
+Author-email: Ke <jiangke1207@icloud.com>
+License-Expression: MIT
+Project-URL: Homepage, https://pypi.org/project/tketool.pipeline/
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: tketool.core[console]==1.3.5
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == "test"
+
+# tketool.pipeline
+
+Small stage-based processing pipelines with ordered decorators, optional
+parallel item processing, and local buffering.
+
+```bash
+pip install tketool.pipeline
+```
+
+```python
+from enum import Enum
+
+from tketool.pipeline import Pipeline, invoke_all
+
+
+class Stage(Enum):
+    PREPARE = "prepare"
+    RUN = "run"
+
+
+class Steps:
+    @invoke_all(Stage.PREPARE.value, priority=10)
+    def prepare(self, board):
+        board.current_data = {"ready": True}
+
+
+pipeline = Pipeline(Stage, acts=[Steps()])
+result = pipeline()
+```
+
+The retired `tketool.injections` path is not shipped.

tketool_pipeline-1.3.5/README.md

@@ -0,0 +1,31 @@
+# tketool.pipeline
+
+Small stage-based processing pipelines with ordered decorators, optional
+parallel item processing, and local buffering.
+
+```bash
+pip install tketool.pipeline
+```
+
+```python
+from enum import Enum
+
+from tketool.pipeline import Pipeline, invoke_all
+
+
+class Stage(Enum):
+    PREPARE = "prepare"
+    RUN = "run"
+
+
+class Steps:
+    @invoke_all(Stage.PREPARE.value, priority=10)
+    def prepare(self, board):
+        board.current_data = {"ready": True}
+
+
+pipeline = Pipeline(Stage, acts=[Steps()])
+result = pipeline()
+```
+
+The retired `tketool.injections` path is not shipped.

tketool_pipeline-1.3.5/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tketool.pipeline"
+version = "1.3.5"
+description = "Stage-based processing pipeline and injection decorators for tketool"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "Ke", email = "jiangke1207@icloud.com" }]
+dependencies = ["tketool.core[console]==1.3.5"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Operating System :: OS Independent",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8,<9"]
+
+[project.urls]
+Homepage = "https://pypi.org/project/tketool.pipeline/"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["tketool*"]
+namespaces = true

tketool_pipeline-1.3.5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tketool_pipeline-1.3.5/src/tketool/pipeline/__init__.py

@@ -0,0 +1,19 @@
+"""Stage-based processing pipeline and execution decorators."""
+
+from .execution import (
+    CrossStageCopy,
+    ExecutionBoard,
+    invoke_all,
+    invoke_one,
+    invoke_per_stage,
+)
+from .pipeline import Pipeline
+
+__all__ = [
+    "CrossStageCopy",
+    "ExecutionBoard",
+    "Pipeline",
+    "invoke_all",
+    "invoke_one",
+    "invoke_per_stage",
+]

tketool_pipeline-1.3.5/src/tketool/pipeline/execution.py

@@ -0,0 +1,218 @@
+import functools, abc
+from enum import Enum
+from tketool.core.progress import ProgressStatusBar
+
+
+def invoke_all(stage, priority: int, buffer=False, enable=True):
+    """
+    装饰器函数，用于标记需要在特定阶段执行的所有方法
+    
+    Args:
+        stage: 执行阶段
+        priority (int): 执行优先级
+        buffer (bool): 是否启用缓冲
+        enable (bool): 是否启用该方法
+    
+    Returns:
+        wrapper: 装饰后的函数
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except Exception as ex:
+                return ex
+
+        wrapper._priority = priority
+        wrapper._stage = stage
+        wrapper._buffer = buffer
+        wrapper._enable = enable
+        return wrapper
+
+    return decorator
+
+
+def invoke_per_stage(priority: int, buffer=False, enable=True):
+    """
+    装饰器函数，用于标记每个阶段都需要执行的方法
+    
+    Args:
+        priority (int): 执行优先级
+        buffer (bool): 是否启用缓冲
+        enable (bool): 是否启用该方法
+    
+    Returns:
+        wrapper: 装饰后的函数
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        wrapper._priority = priority
+        wrapper._buffer = buffer
+        wrapper._enable = enable
+        return wrapper
+
+    return decorator
+
+
+def invoke_one(stage, priority: int, enum_key: str = None, parallel: bool = False,
+               buffer=False, enable=True, pass_to=0):
+    """
+    装饰器函数，用于标记在特定阶段只执行一次的方法
+    
+    Args:
+        stage: 执行阶段
+        priority (int): 执行优先级
+        enum_key (str): 枚举键名
+        parallel (bool): 是否允许并行执行
+        buffer (bool): 是否启用缓冲
+        enable (bool): 是否启用该方法
+        pass_to (int): 传递目标
+    
+    Returns:
+        wrapper: 装饰后的函数
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        wrapper._priority = priority
+        wrapper._enum_key = enum_key
+        wrapper._stage = stage
+        wrapper._parallel = parallel
+        wrapper._buffer = buffer
+        wrapper._enable = enable
+        wrapper._pass_to = pass_to
+        return wrapper
+
+    return decorator
+
+
+class CrossStageCopy:
+
+    @invoke_per_stage(priority=0)
+    def cross_copy(self, board):
+        """
+        在不同阶段间复制数据的方法
+        
+        Args:
+            board: 数据面板对象，包含当前阶段和上一阶段的数据
+        """
+        if board.last_data is None:
+            return
+        elif isinstance(board.last_data, list):
+            board.current_data = []
+            for item in board.last_data:
+                board.current_data.append(item)
+        elif isinstance(board.last_data, dict):
+            board.current_data = {}
+            for k, v in board.last_data.items():
+                board.current_data[k] = v
+
+
+class ExecutionBoard:
+    """
+    用于管理执行阶段和数据的面板类
+    """
+    
+    def __init__(self):
+        """
+        初始化执行面板
+        """
+        self.current_stage = None
+        self.last_stage = None
+        self.process_bar = ProgressStatusBar(progress_bar_length=10, max_str_length=200)
+
+        self.sub_process_info = []
+        self.oper_dict = {}
+        self.stages = {}
+        self.logs = []
+        self.additional_dict = {}
+
+    @property
+    def serialize_tuple(self):
+        """
+        获取序列化数据元组
+        
+        Returns:
+            tuple: 包含面板所有数据的元组
+        """
+        return (self.sub_process_info, self.oper_dict, self.stages, self.logs, self.additional_dict)
+
+    @serialize_tuple.setter
+    def serialize_tuple(self, value):
+        """
+        从序列化数据元组恢复面板数据
+        
+        Args:
+            value: 包含面板数据的元组
+        """
+        self.sub_process_info = value[0]
+        self.oper_dict = value[1]
+        self.stages = value[2]
+        self.logs = value[3]
+        self.additional_dict = value[4]
+
+        for k, v in self.additional_dict.items():
+            self.__setattr__(k, v)
+
+    def set_field(self, key, value):
+        """
+        设置面板的附加字段
+        
+        Args:
+            key: 字段名
+            value: 字段值
+        """
+        self.additional_dict[key] = value
+        self.__setattr__(key, value)
+
+    def set_stage(self, stage):
+        """
+        设置当前执行阶段
+        
+        Args:
+            stage: 要设置的阶段
+        """
+        if stage not in self.stages:
+            self.stages[stage] = {}
+        self.last_stage = self.current_stage
+        self.current_stage = stage
+
+    @property
+    def current_data(self):
+        """
+        获取当前阶段的数据
+        
+        Returns:
+            当前阶段的数据，如果当前阶段未设置则返回None
+        """
+        if self.current_stage is None:
+            return None
+        return self.stages[self.current_stage]
+
+    @property
+    def last_data(self):
+        """
+        获取上一阶段的数据
+        
+        Returns:
+            上一阶段的数据，如果上一阶段未设置则返回None
+        """
+        if self.last_stage is None:
+            return None
+        return self.stages[self.last_stage]
+
+    @current_data.setter
+    def current_data(self, v):
+        """
+        设置当前阶段的数据
+        
+        Args:
+            v: 要设置的数据
+        """
+        self.stages[self.current_stage] = v

tketool_pipeline-1.3.5/src/tketool/pipeline/pipeline.py

@@ -0,0 +1,386 @@
+from tketool.pipeline.execution import ExecutionBoard
+import time
+from tketool.core.concurrency import execute_multitask
+from tketool.core.cache.base import buffer_item, flush, get_buffer_item, has_item_key
+from tketool.core.cache import shelve_many as _shelve_many
+
+
+class Pipeline:
+    """
+    多阶段处理管道类，支持按阶段执行不同的处理函数，具备并行处理和缓冲机制
+    
+    主要功能：
+    - 支持多阶段串行执行
+    - 支持多线程并行处理
+    - 支持结果缓冲和恢复
+    - 支持按优先级排序执行
+    - 支持忽略指定函数
+    
+    使用示例：
+        ```python
+        from enum import Enum
+        
+        class ProcessStages(Enum):
+            INIT = "init"
+            PROCESS = "process"
+            FINISH = "finish"
+        
+        class MyProcessor:
+            @invoke_all("init", priority=1)
+            def setup(self, board):
+                board.current_data = {"status": "initialized"}
+            
+            @invoke_one("process", priority=1, enum_key="items", parallel=True)
+            def process_item(self, item, board):
+                return f"processed_{item}"
+        
+        processor = MyProcessor()
+        pipeline = Pipeline(ProcessStages, acts=[processor], thread_count=4)
+        result = pipeline(items=["item1", "item2", "item3"])
+        ```
+    """
+    
+    def __init__(self, stages, acts=[], ignore_funs=[], thread_count=1):
+        """
+        初始化处理管道
+        
+        Args:
+            stages: 处理阶段列表或枚举类
+                    - 如果是枚举类，会自动提取所有成员名称
+                    - 如果是列表，直接使用
+            acts (list): 处理类实例列表，包含用装饰器标记的处理方法
+            ignore_funs (list): 要忽略的函数名称列表，格式为"ClassName.method_name"
+            thread_count (int): 并行处理的线程数，默认为1
+            
+        示例：
+            ```python
+            # 使用枚举定义阶段
+            pipeline = Pipeline(MyStages, acts=[processor1, processor2], thread_count=4)
+            
+            # 使用列表定义阶段
+            pipeline = Pipeline(["init", "process", "finish"], acts=[processor])
+            
+            # 忽略特定方法
+            pipeline = Pipeline(stages, acts=[processor], ignore_funs=["MyProcessor.debug_method"])
+            ```
+        """
+        if isinstance(stages, list):
+            self.all_stages = stages
+        else:
+            # 从枚举类中提取成员值（而不是名称）
+            self.all_stages = [memb.value for name, memb in stages.__members__.items()]
+
+        self.multi_thread_count = thread_count
+        self.all_injection_class = acts
+        self.sub_processes = {k: [] for k in self.all_stages}
+        self.ignore_names = set(ignore_funs)
+        
+        # 扫描所有处理类，提取标记的方法
+        for pl in self.all_injection_class:
+            for name, funs in self._get_process_map(pl).items():
+                if name in self.ignore_names:
+                    continue
+                    
+                # 如果方法指定了特定阶段，只在该阶段执行
+                if 'stage' in funs:
+                    if funs['stage'] in self.sub_processes:
+                        self.sub_processes[funs['stage']].append(funs)
+                else:
+                    # 否则在所有阶段都执行
+                    for st in self.all_stages:
+                        self.sub_processes[st].append(funs)
+
+        # 按优先级排序各阶段的处理函数
+        for key in self.sub_processes.keys():
+            self.sub_processes[key].sort(key=lambda x: x['priority'])
+
+        self.buffer_switch = True
+
+    def disable_buffer(self):
+        """
+        禁用缓冲机制
+        
+        调用此方法后，所有处理过程将不再使用缓冲，每次都会重新执行
+        
+        示例：
+            ```python
+            pipeline = Pipeline(stages, acts=[processor])
+            pipeline.disable_buffer()  # 禁用缓冲
+            result = pipeline()  # 不使用缓冲执行
+            ```
+        """
+        self.buffer_switch = False
+
+    def _get_process_map(self, target) -> dict:
+        """
+        从目标对象中提取所有标记的处理方法
+        
+        Args:
+            target: 要扫描的对象实例
+            
+        Returns:
+            dict: 包含方法信息的字典，键为方法名，值为方法元数据
+            
+        方法元数据包含：
+            - name: 方法名称
+            - type: 处理类型 ("one" 或 "all")
+            - stage: 执行阶段（可选）
+            - priority: 优先级
+            - func: 方法对象
+            - 其他装饰器参数
+        """
+        run_list = {}
+        for name in dir(target):
+            method = getattr(target, name)
+            process_name = f"{type(target).__name__}.{name}"
+            
+            # 检查方法是否有优先级标记（表示被装饰器处理过）
+            if hasattr(method, '_priority'):
+                method_info = {
+                    'name': process_name,
+                    'priority': method._priority,
+                    'buffer': method._buffer,
+                    'func': method,
+                    'enable': method._enable,
+                }
+                
+                # 检查是否是单项处理方法（invoke_one装饰的）
+                if hasattr(method, '_enum_key'):
+                    method_info.update({
+                        'type': "one",
+                        'stage': method._stage,
+                        'key': method._enum_key,
+                        'pass_to': method._pass_to,
+                        'parallel': method._parallel,
+                    })
+                elif not hasattr(method, '_stage'):
+                    # 全阶段方法但没有指定特定阶段
+                    method_info['type'] = "all"
+                else:
+                    # 特定阶段的全量处理方法
+                    method_info.update({
+                        'type': "all",
+                        'stage': method._stage,
+                    })
+                
+                run_list[process_name] = method_info
+
+        return run_list
+
+    def _execute_process(self, board, process_info):
+        """
+        执行单个处理过程
+        
+        Args:
+            board: 执行面板对象
+            process_info (dict): 处理方法的元数据信息
+            
+        根据处理类型执行不同逻辑：
+        - "all"类型：直接调用方法处理整个数据面板
+        - "one"类型：遍历数据项，逐个处理
+        """
+        if process_info['type'] == "all":
+            # 全量处理，直接传入整个面板
+            process_info['func'](board)
+        elif process_info['type'] == "one":
+            # 单项处理
+            if len(board.current_data) == 0:
+                board.logs.append("当前数据为空，跳过单项处理。")
+                return
+
+            # 获取要处理的数据项
+            if isinstance(board.current_data, list):
+                enum_datas = board.current_data
+            else:
+                enum_datas = board.current_data[process_info['key']]
+            
+            # 从指定位置开始处理
+            enum_datas = enum_datas[process_info["pass_to"]:]
+            
+            if process_info['parallel']:
+                # 并行处理
+                def do_func(item):
+                    return process_info['func'](item, board)
+
+                # 使用多线程处理并显示进度条
+                for item, result in board.process_bar.iter_bar(
+                        execute_multitask(enum_datas, do_func, 
+                                        thread_count=self.multi_thread_count,
+                                        max_queue_buffer=self.multi_thread_count * 10),
+                        key=process_info['name'], max_count=len(enum_datas)):
+                    if result is not None:
+                        # 保存处理结果（只对支持属性设置的对象）
+                        try:
+                            if not hasattr(item, 'process_result'):
+                                item.process_result = {}
+                            item.process_result[process_info['name']] = result
+                        except (AttributeError, TypeError):
+                            # 对于基本类型（如 int, str），无法设置属性，忽略结果保存
+                            pass
+            else:
+                # 串行处理
+                for item in board.process_bar.iter_bar(enum_datas, key=process_info['name']):
+                    result = process_info['func'](item, board)
+                    if result is not None:
+                        # 保存处理结果（只对支持属性设置的对象）
+                        try:
+                            if not hasattr(item, 'process_result'):
+                                item.process_result = {}
+                            item.process_result[process_info['name']] = result
+                        except (AttributeError, TypeError):
+                            # 对于基本类型（如 int, str），无法设置属性，忽略结果保存
+                            pass
+
+    def _execute_buffer(self, board, process_info):
+        """
+        执行带缓冲的处理过程
+        
+        Args:
+            board: 执行面板对象
+            process_info (dict): 处理方法的元数据信息
+            
+        Returns:
+            tuple: (是否使用了缓冲, 缓冲文件路径)
+            
+        缓冲机制：
+        - 如果启用缓冲且该方法支持缓冲，会尝试从缓冲中恢复结果
+        - 如果缓冲不存在，执行处理并保存结果到缓冲
+        - 缓冲键值基于方法名生成
+        """
+        if self.buffer_switch and process_info['buffer']:
+            buffer_key = process_info['name'].replace('.', '_')
+
+            if has_item_key(buffer_key):
+                # 从缓冲恢复数据
+                board.serialize_tuple = get_buffer_item(buffer_key)
+                return True, buffer_key
+            else:
+                # 执行处理并保存到缓冲
+                self._execute_process(board, process_info)
+                buffer_item(buffer_key, board.serialize_tuple)
+                flush()
+                return False, buffer_key
+        else:
+            # 不使用缓冲，直接执行
+            self._execute_process(board, process_info)
+            return False, ""
+
+    def _execute_stage(self, board: ExecutionBoard):
+        """
+        执行当前阶段的所有处理过程
+        
+        Args:
+            board: 执行面板对象，包含当前阶段信息
+            
+        按优先级顺序执行当前阶段的所有处理方法，记录执行信息和耗时
+        """
+        if board.current_stage in self.sub_processes:
+            stage_processes = self.sub_processes[board.current_stage]
+            
+            for process_info in board.process_bar.iter_bar(stage_processes, key="sub_process"):
+                if not process_info['enable']:
+                    board.logs.append(f"跳过已禁用的处理过程: {process_info['name']}")
+                    continue
+                    
+                board.logs.append(
+                    f"开始处理: {process_info['name']}, "
+                    f"优先级: {process_info['priority']}, "
+                    f"使用缓冲: {process_info['buffer']}"
+                )
+
+                start_timestamp = time.time()
+                use_buffer, buffer_file = self._execute_buffer(board, process_info)
+
+                # 记录处理信息
+                board.sub_process_info.append({
+                    "process_name": process_info['name'],
+                    "stage": board.current_stage,
+                    "use_buffer": use_buffer,
+                    "buffer_file": buffer_file,
+                    "cost": time.time() - start_timestamp,
+                })
+
+    def __call__(self, **kwargs):
+        """
+        执行整个处理管道
+        
+        Args:
+            **kwargs: 传递给执行面板的初始参数
+            
+        Returns:
+            ExecutionBoard: 执行完成后的面板对象，包含所有阶段的处理结果
+            
+        示例：
+            ```python
+            # 传入初始数据
+            result = pipeline(data=[1, 2, 3], config={"debug": True})
+            
+            # 访问结果
+            print(result.logs)  # 查看执行日志
+            print(result.sub_process_info)  # 查看各步骤执行信息
+            print(result.stages)  # 查看各阶段数据
+            ```
+        """
+        board = ExecutionBoard()
+
+        # 设置初始参数
+        for k, v in kwargs.items():
+            setattr(board, k, v)
+
+        # 按顺序执行各阶段
+        for stage in board.process_bar.iter_bar(self.all_stages, key='stages'):
+            board.set_stage(stage)
+            self._execute_stage(board)
+
+        return board
+
+
+"""
+改进建议和可增加的功能：
+
+1. 错误处理改进：
+   - 添加异常捕获和重试机制
+   - 支持容错模式，某个步骤失败不影响后续执行
+   - 添加详细的错误日志和堆栈信息
+
+2. 性能优化：
+   - 支持动态调整线程数
+   - 添加内存使用监控
+   - 支持大数据流式处理，避免内存溢出
+
+3. 功能增强：
+   - 支持条件执行（根据前一阶段结果决定是否执行）
+   - 支持分支和合并逻辑
+   - 添加钩子函数（before/after hooks）
+   - 支持暂停和恢复执行
+
+4. 监控和调试：
+   - 添加详细的性能指标收集
+   - 支持实时监控执行状态
+   - 添加可视化的执行流程图
+   - 支持断点调试模式
+
+5. 配置管理：
+   - 支持从配置文件加载管道定义
+   - 支持动态修改处理参数
+   - 添加参数验证机制
+
+6. 扩展性：
+   - 支持插件系统
+   - 添加事件驱动机制
+   - 支持分布式执行
+
+示例扩展实现：
+
+class AdvancedPipeline(Pipeline):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.error_handlers = {}
+        self.retry_config = {"max_retries": 3, "delay": 1}
+    
+    def add_error_handler(self, stage, handler):
+        self.error_handlers[stage] = handler
+    
+    def set_retry_config(self, max_retries=3, delay=1):
+        self.retry_config = {"max_retries": max_retries, "delay": delay}
+"""

tketool_pipeline-1.3.5/src/tketool.pipeline.egg-info/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: tketool.pipeline
+Version: 1.3.5
+Summary: Stage-based processing pipeline and injection decorators for tketool
+Author-email: Ke <jiangke1207@icloud.com>
+License-Expression: MIT
+Project-URL: Homepage, https://pypi.org/project/tketool.pipeline/
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: tketool.core[console]==1.3.5
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == "test"
+
+# tketool.pipeline
+
+Small stage-based processing pipelines with ordered decorators, optional
+parallel item processing, and local buffering.
+
+```bash
+pip install tketool.pipeline
+```
+
+```python
+from enum import Enum
+
+from tketool.pipeline import Pipeline, invoke_all
+
+
+class Stage(Enum):
+    PREPARE = "prepare"
+    RUN = "run"
+
+
+class Steps:
+    @invoke_all(Stage.PREPARE.value, priority=10)
+    def prepare(self, board):
+        board.current_data = {"ready": True}
+
+
+pipeline = Pipeline(Stage, acts=[Steps()])
+result = pipeline()
+```
+
+The retired `tketool.injections` path is not shipped.

tketool_pipeline-1.3.5/src/tketool.pipeline.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/tketool.pipeline.egg-info/PKG-INFO
+src/tketool.pipeline.egg-info/SOURCES.txt
+src/tketool.pipeline.egg-info/dependency_links.txt
+src/tketool.pipeline.egg-info/requires.txt
+src/tketool.pipeline.egg-info/top_level.txt
+src/tketool/pipeline/__init__.py
+src/tketool/pipeline/execution.py
+src/tketool/pipeline/pipeline.py

tketool_pipeline-1.3.5/src/tketool.pipeline.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tketool_pipeline-1.3.5/src/tketool.pipeline.egg-info/requires.txt

@@ -0,0 +1,4 @@
+tketool.core[console]==1.3.5
+
+[test]
+pytest<9,>=8

tketool_pipeline-1.3.5/src/tketool.pipeline.egg-info/top_level.txt

@@ -0,0 +1 @@
+tketool