pysfi 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

sfi/workflowengine/workflowengine.py

@@ -3,6 +3,13 @@
 This module provides a comprehensive workflow engine for managing
 complex task dependencies with support for I/O tasks, CPU-intensive tasks,
 serial tasks, and parallel task execution.
+
+The engine supports:
+- Dependency management with cycle detection
+- Topological sorting for execution order
+- Concurrent execution with configurable limits
+- Error handling and timeout management
+- Execution monitoring and reporting
 """
 
 from __future__ import annotations
@@ -49,7 +56,13 @@ class TaskResult:
 class Task(ABC):
     """Task abstract base class"""
 
-    def __init__(self, task_id: str, task_type: TaskType, dependencies: list[str] | None = None, timeout: float = 30.0):
+    def __init__(
+        self,
+        task_id: str,
+        task_type: TaskType,
+        dependencies: list[str] | None = None,
+        timeout: float = 30.0,
+    ):
         self.task_id = task_id
         self.task_type = task_type
         self.dependencies = dependencies or []
@@ -82,18 +95,68 @@ class Task(ABC):
             return self.end_time - self.start_time
         return 0.0
 
+    async def _execute_with_error_handling(
+        self, execution_func, context: dict[str, TaskResult]
+    ):
+        """Common execution wrapper with error handling"""
+        self.start_time = time.time()
+        self.update_status(TaskStatus.RUNNING)
+
+        try:
+            data = await asyncio.wait_for(execution_func(context), timeout=self.timeout)
+            self.end_time = time.time()
+            self.result = TaskResult(
+                task_id=self.task_id,
+                success=True,
+                data=data,
+                execution_time=self.get_execution_time(),
+            )
+            self.update_status(TaskStatus.COMPLETED)
+            return self.result
+        except asyncio.TimeoutError as e:
+            self.end_time = time.time()
+            self.result = TaskResult(
+                task_id=self.task_id,
+                success=False,
+                data=None,
+                execution_time=self.get_execution_time(),
+                error=e,
+            )
+            self.update_status(TaskStatus.FAILED)
+            raise
+        except Exception as e:
+            self.end_time = time.time()
+            self.result = TaskResult(
+                task_id=self.task_id,
+                success=False,
+                data=None,
+                execution_time=self.get_execution_time(),
+                error=e,
+            )
+            self.update_status(TaskStatus.FAILED)
+            raise
+
 
 class IOTask(Task):
     """I/O-intensive task"""
 
-    def __init__(self, task_id: str, duration: float, dependencies: list[str] | None = None, timeout: float = 30.0):
+    def __init__(
+        self,
+        task_id: str,
+        duration: float,
+        dependencies: list[str] | None = None,
+        timeout: float = 30.0,
+    ):
         super().__init__(task_id, TaskType.ASYNC, dependencies, timeout)
         self.duration = duration
 
     async def execute(self, context: dict[str, TaskResult]) -> Any:
         """Simulate I/O operation"""
-        print(f"[IO] Starting task {self.task_id}, estimated duration: {self.duration}s")
-        return await asyncio.wait_for(self._execute_io(context), timeout=self.timeout)
+        print(
+            f"[IO] Starting task {self.task_id}, estimated duration: {self.duration}s"
+        )
+        result = await self._execute_with_error_handling(self._execute_io, context)
+        return result.data
 
     async def _execute_io(self, context: dict[str, TaskResult]) -> Any:
         """Internal I/O execution method"""
@@ -104,25 +167,34 @@ class IOTask(Task):
 class CPUTask(Task):
     """CPU-intensive task"""
 
-    def __init__(self, task_id: str, iterations: int, dependencies: list[str] | None = None, timeout: float = 30.0):
+    def __init__(
+        self,
+        task_id: str,
+        iterations: int,
+        dependencies: list[str] | None = None,
+        timeout: float = 30.0,
+    ):
         super().__init__(task_id, TaskType.CPU, dependencies, timeout)
         self.iterations = iterations
 
     async def execute(self, context: dict[str, TaskResult]) -> Any:
         """CPU-intensive computation task"""
         print(f"[CPU] Starting task {self.task_id}, iterations: {self.iterations}")
+        result = await self._execute_with_error_handling(self._execute_cpu, context)
+        return result.data
+
+    async def _execute_cpu(self, context: dict[str, TaskResult]) -> Any:
+        """Execute CPU-intensive work in thread pool"""
 
-        # Move CPU-intensive task to thread pool to avoid blocking event loop
         def cpu_intensive_work():
             result = 0
             for i in range(self.iterations):
                 result += i * i
             return result
 
-        # Use asyncio.wait_for with timeout to prevent infinite hangs
-        # Use run_in_executor for Python 3.8 compatibility (asyncio.to_thread is Python 3.9+)
+        # Use run_in_executor to avoid blocking event loop
         loop = asyncio.get_event_loop()
-        result = await asyncio.wait_for(loop.run_in_executor(None, cpu_intensive_work), timeout=self.timeout)
+        result = await loop.run_in_executor(None, cpu_intensive_work)
         return f"CPU task {self.task_id} completed, result: {result}"
 
 
@@ -130,7 +202,11 @@ class SerialTask(Task):
     """Serial task (stateful, must execute sequentially)"""
 
     def __init__(
-        self, task_id: str, process_func: Callable, dependencies: list[str] | None = None, timeout: float = 30.0
+        self,
+        task_id: str,
+        process_func: Callable,
+        dependencies: list[str] | None = None,
+        timeout: float = 30.0,
     ):
         super().__init__(task_id, TaskType.SERIAL, dependencies, timeout)
         self.process_func = process_func
@@ -139,7 +215,11 @@ class SerialTask(Task):
     async def execute(self, context: dict[str, TaskResult]) -> Any:
         """Execute serial task"""
         print(f"[Serial] Starting serial task {self.task_id}")
+        result = await self._execute_with_error_handling(self._execute_serial, context)
+        return result.data
 
+    async def _execute_serial(self, context: dict[str, TaskResult]) -> Any:
+        """Execute serial task logic"""
         # Collect results from dependent tasks
         inputs = {dep_id: context[dep_id].data for dep_id in self.dependencies}
 
@@ -172,61 +252,71 @@ class ParallelTask(Task):
 
     async def execute(self, context: dict[str, TaskResult]) -> Any:
         """Execute subtasks in parallel"""
-        print(f"[Parallel] Starting parallel task {self.task_id}, contains {len(self.subtasks)} subtasks")
-
+        print(
+            f"[Parallel] Starting parallel task {self.task_id}, contains {len(self.subtasks)} subtasks"
+        )
+        result = await self._execute_with_error_handling(
+            self._execute_parallel, context
+        )
+        return result.data
+
+    async def _execute_parallel(self, context: dict[str, TaskResult]) -> Any:
+        """Execute subtasks in parallel with controlled concurrency"""
         # Create semaphore to control concurrency
         semaphore = asyncio.Semaphore(self.max_concurrent)
 
-        async def execute_subtask(subtask: Task, sem: asyncio.Semaphore):
-            async with sem:
-                subtask.start_time = time.time()
-                subtask.update_status(TaskStatus.RUNNING)
-
+        async def execute_subtask_with_semaphore(subtask: Task):
+            async with semaphore:
+                # Execute subtask with its own context
                 try:
-                    data = await asyncio.wait_for(subtask.execute(context), timeout=subtask.timeout)
+                    data = await asyncio.wait_for(
+                        subtask.execute(context), timeout=subtask.timeout
+                    )
                     subtask.result = TaskResult(
                         task_id=subtask.task_id,
                         success=True,
                         data=data,
-                        execution_time=time.time() - subtask.start_time,
+                        execution_time=time.time() - subtask.start_time
+                        if subtask.start_time
+                        else 0,
                     )
                     subtask.update_status(TaskStatus.COMPLETED)
                     return subtask.result
-                except asyncio.TimeoutError as e:
-                    error = TimeoutError(f"Task {subtask.task_id} execution timeout")
-                    subtask.result = TaskResult(
-                        task_id=subtask.task_id,
-                        success=False,
-                        data=None,
-                        execution_time=time.time() - subtask.start_time,
-                        error=error,
-                    )
-                    subtask.update_status(TaskStatus.FAILED)
-                    raise error from e
                 except Exception as e:
+                    subtask.end_time = time.time()
                     subtask.result = TaskResult(
                         task_id=subtask.task_id,
                         success=False,
                         data=None,
-                        execution_time=time.time() - subtask.start_time,
+                        execution_time=time.time() - subtask.start_time
+                        if subtask.start_time
+                        else 0,
                         error=e,
                     )
                     subtask.update_status(TaskStatus.FAILED)
-                    raise e
+                    return subtask.result
 
         # Execute all subtasks in parallel
-        tasks = [execute_subtask(subtask, semaphore) for subtask in self.subtasks]
-        results = await asyncio.gather(*tasks, return_exceptions=True)
+        results = await asyncio.gather(
+            *[execute_subtask_with_semaphore(subtask) for subtask in self.subtasks],
+            return_exceptions=True,
+        )
 
-        # Process results using zip for better readability
+        # Process results
         successful_results = []
         failed_results = []
 
-        for subtask, result in zip(self.subtasks, results):
+        for i, result in enumerate(results):
+            subtask = self.subtasks[i]
             if isinstance(result, Exception):
                 failed_results.append(f"Subtask {subtask.task_id} failed: {result}")
             elif isinstance(result, TaskResult):
-                successful_results.append(result.data)
+                if result.success:
+                    successful_results.append(result.data)
+                else:
+                    failed_results.append(
+                        f"Subtask {subtask.task_id} failed: {result.error}"
+                    )
 
         if failed_results:
             return f"Parallel task {self.task_id} partially failed: {failed_results}"
@@ -336,86 +426,8 @@ class WorkflowEngine:
         for level_index, level in enumerate(execution_order, 1):
             print(f"\n{'=' * 20} Phase {level_index} ({len(level)} tasks) {'=' * 20}")
 
-            # Filter executable tasks in this level
-            ready_tasks = []
-            for task_id in level:
-                task = self.tasks[task_id]
-                if task.can_execute(completed_tasks):
-                    task.update_status(TaskStatus.READY)
-                    ready_tasks.append(task)
-
-            if not ready_tasks:
-                continue
-
-            # Create semaphore for this level to control concurrency
-            semaphore = asyncio.Semaphore(self.max_concurrent)
-
-            async def execute_single_task(task: Task, sem: asyncio.Semaphore):
-                async with sem:
-                    task.start_time = time.time()
-                    task.update_status(TaskStatus.RUNNING)
-
-                    try:
-                        # Collect results from dependent tasks
-                        dependency_results = {dep_id: self.results[dep_id] for dep_id in task.get_dependencies()}
-
-                        # Execute task
-                        data = await asyncio.wait_for(task.execute(dependency_results), timeout=task.timeout)
-
-                        task.end_time = time.time()
-                        task.result = TaskResult(
-                            task_id=task.task_id, success=True, data=data, execution_time=task.get_execution_time()
-                        )
-                        task.update_status(TaskStatus.COMPLETED)
-
-                        # Store result
-                        self.results[task.task_id] = task.result
-                        completed_tasks.add(task.task_id)
-
-                        print(f"[OK] Task {task.task_id} completed, duration: {task.get_execution_time():.2f}s")
-
-                        return task.result
-
-                    except asyncio.TimeoutError as e:
-                        task.end_time = time.time()
-                        task.result = TaskResult(
-                            task_id=task.task_id,
-                            success=False,
-                            data=None,
-                            execution_time=task.get_execution_time(),
-                            error=e,
-                        )
-                        task.update_status(TaskStatus.FAILED)
-
-                        # Store result and mark as completed (even if failed)
-                        self.results[task.task_id] = task.result
-                        completed_tasks.add(task.task_id)
-
-                        print(f"[FAIL] Task {task.task_id} timeout")
-                        raise e from e
-                    except Exception as e:
-                        task.end_time = time.time()
-                        task.result = TaskResult(
-                            task_id=task.task_id,
-                            success=False,
-                            data=None,
-                            execution_time=task.get_execution_time(),
-                            error=e,
-                        )
-                        task.update_status(TaskStatus.FAILED)
-
-                        # Store result and mark as completed (even if failed)
-                        self.results[task.task_id] = task.result
-                        completed_tasks.add(task.task_id)
-
-                        print(f"[FAIL] Task {task.task_id} failed: {e}")
-                        raise e
-
-            # Execute all ready tasks in this level in parallel
-            tasks_to_execute = [execute_single_task(task, semaphore) for task in ready_tasks]
-
-            # Use return_exceptions=True to ensure all tasks complete even if some fail
-            await asyncio.gather(*tasks_to_execute, return_exceptions=True)
+            # Execute the current level
+            await self._execute_level(level, completed_tasks)
 
         print(f"\n{'=' * 50}")
         print("Workflow execution completed")
@@ -423,22 +435,113 @@ class WorkflowEngine:
 
         return self.results
 
+    async def _execute_level(self, level: list[str], completed_tasks: set[str]):
+        """Execute a single level of tasks with controlled concurrency."""
+        # Filter executable tasks in this level
+        ready_tasks = []
+        for task_id in level:
+            task = self.tasks[task_id]
+            if task.can_execute(completed_tasks):
+                task.update_status(TaskStatus.READY)
+                ready_tasks.append(task)
+
+        if not ready_tasks:
+            return
+
+        # Use a shared semaphore for this level to control concurrency
+        semaphore = asyncio.Semaphore(self.max_concurrent)
+
+        # Execute all ready tasks in this level in parallel
+        tasks_to_execute = [
+            self._execute_single_task_with_semaphore(task, semaphore, completed_tasks)
+            for task in ready_tasks
+        ]
+
+        # Use return_exceptions=True to ensure all tasks complete even if some fail
+        await asyncio.gather(*tasks_to_execute, return_exceptions=True)
+
+    async def _execute_single_task_with_semaphore(
+        self, task: Task, semaphore: asyncio.Semaphore, completed_tasks: set[str]
+    ):
+        """Execute a single task with semaphore control for concurrency."""
+        async with semaphore:
+            return await self._execute_single_task(task, completed_tasks)
+
+    async def _execute_single_task(self, task: Task, completed_tasks: set[str]):
+        """Execute a single task with error handling."""
+        task.start_time = time.time()
+        task.update_status(TaskStatus.RUNNING)
+
+        # Collect results from dependent tasks
+        dependency_results = {
+            dep_id: self.results[dep_id] for dep_id in task.get_dependencies()
+        }
+
+        try:
+            # Execute task using the common error handling wrapper
+            result_data = await task._execute_with_error_handling(
+                lambda ctx: task.execute(ctx), dependency_results
+            )
+            # Update task with result
+            task.result = result_data
+        except Exception:
+            # Result is already stored in task.result by _execute_with_error_handling
+            pass
+
+        # Store result and update completed tasks (even if failed)
+        self.results[task.task_id] = task.result
+        completed_tasks.add(task.task_id)
+
+        # Print appropriate message based on result
+        if task.result.success:
+            print(
+                f"[OK] Task {task.task_id} completed, duration: {task.get_execution_time():.2f}s"
+            )
+        else:
+            error_msg = (
+                "timeout"
+                if isinstance(task.result.error, asyncio.TimeoutError)
+                else str(task.result.error)
+            )
+            print(f"[FAIL] Task {task.task_id} failed: {error_msg}")
+
+        return task.result
+
     def get_execution_summary(self) -> dict[str, Any]:
         """Get execution summary"""
         total_tasks = len(self.tasks)
-        completed = sum(1 for task in self.tasks.values() if task.status == TaskStatus.COMPLETED)
-        failed = sum(1 for task in self.tasks.values() if task.status == TaskStatus.FAILED)
-
+        if total_tasks == 0:
+            return {
+                "total_tasks": 0,
+                "completed": 0,
+                "failed": 0,
+                "pending": 0,
+                "total_execution_time": 0.0,
+                "success_rate": 0.0,
+            }
+
+        completed = 0
+        failed = 0
         total_time = 0.0
+
+        # Single pass through tasks to calculate all metrics
         for task in self.tasks.values():
+            if task.status == TaskStatus.COMPLETED:
+                completed += 1
+            elif task.status == TaskStatus.FAILED:
+                failed += 1
+
             if task.result:
                 total_time += task.result.execution_time
 
+        pending = total_tasks - completed - failed
+        success_rate = completed / total_tasks if total_tasks > 0 else 0
+
         return {
             "total_tasks": total_tasks,
             "completed": completed,
             "failed": failed,
-            "pending": total_tasks - completed - failed,
+            "pending": pending,
             "total_execution_time": total_time,
-            "success_rate": completed / total_tasks if total_tasks > 0 else 0,
+            "success_rate": success_rate,
         }

pysfi-0.1.11.dist-info/RECORD

@@ -1,60 +0,0 @@
-sfi/__init__.py,sha256=W9IqwgCQr3sYmRyRC3ryCaJDJcMWBtyLzxp5CVsT3Nc,75
-sfi/cli.py,sha256=bUUTOg18sJQbSKSfsVANhlMgSj9yzO2txIzFAd9B2Ok,296
-sfi/alarmclock/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/alarmclock/alarmclock.py,sha256=0HoacKlGdYq_hINAdl54Cz2E_z6nNjPyqif2xcEBQss,12381
-sfi/bumpversion/__init__.py,sha256=j3XC03YiSDWRJV6UOcDWWsp09STfV5LrvzFkjsehSwA,86
-sfi/bumpversion/bumpversion.py,sha256=HOyHLaE0sZajrlcVZ8hsim8mPjz77qwQVSo6aIzjMXE,20735
-sfi/cleanbuild/cleanbuild.py,sha256=Fr6_cr3rj4llcEQ8yNTK-DHdSzmx1I4hYFJJHu5YEz0,5200
-sfi/condasetup/condasetup.py,sha256=RlbXVYcAJYMau-ZzHOMzHrHl4r-lqNZO0bT-zWuzP_k,4581
-sfi/docscan/__init__.py,sha256=qKkwfRoVBNMzNNdQk69QnFUrmJACtW9qbvoRloTDHfk,121
-sfi/docscan/docscan.py,sha256=rk8mjEI2SKNIliV-Yb41pfUmYBQ1tUhk5LHUNEjkszI,41890
-sfi/docscan/docscan_gui.py,sha256=T_blCyGGaWxL6rtjLIYW3nGdX8DpLQv73YbDnITR4eg,50671
-sfi/docscan/lang/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/docscan/lang/eng.py,sha256=GcOcT9FLcPZRdJ-MbLRYyf6vDweZTQBu_zUnEFzRY84,8529
-sfi/docscan/lang/zhcn.py,sha256=1SZwQjZF3oi9FsnzuZB-9v7P64sGm5oNmVjuL-rhcEQ,8885
-sfi/filedate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/filedate/filedate.py,sha256=5FARcsB2Rlz2uTBxeYYjbIEJb9l1cyXj9WSoNKvSrRo,6068
-sfi/gittool/__init__.py,sha256=Xqxw7UUX-TKkWOCB1QHq8AdIKTkU7x87Xr-E0yVmObA,24
-sfi/gittool/gittool.py,sha256=BBE6gm9qP1fAWLqKprmsf7bOFgDvBvia8_bMaXc7dR4,11960
-sfi/llmclient/llmclient.py,sha256=SnFZ9c2cNvFeLeobJV1ls7Ewftaam4s-HVBYW2tgHPo,21706
-sfi/llmquantize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/llmquantize/llmquantize.py,sha256=ILmfdJg7Rc7xAygfcVgkSKJ_qRAHDRZXjBymYFBy6fg,17693
-sfi/llmserver/llmserver.py,sha256=vYEcNOV-OEvDULpzzCAJ0zHrXgqJFolOhqNdCZU0Bjs,11339
-sfi/makepython/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/makepython/makepython.py,sha256=87lySTg0j1lZNIJMf8U_Go_fkuLkuwGDUf6LUbR_r6c,11445
-sfi/pdfsplit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/pdfsplit/pdfsplit.py,sha256=QWtW3GU28U2ZOyN5sCbH7jEMBpNbuAIzjXWOAXXW44M,6209
-sfi/pyarchive/pyarchive.py,sha256=1rkWY96U_DWbgTvdFGZto7dfutfhUo-OxmoVoaTo6WU,12892
-sfi/pyembedinstall/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/pyembedinstall/pyembedinstall.py,sha256=kxp5YuwNHB29AVBMEJvzaIqTc7bEx-oBpKReGRJ1Pyw,23737
-sfi/pylibpack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/pylibpack/pylibpack.py,sha256=lcGrzijibFFaJnxL8ZVALAGNHGs3g7-N4DO_AuiKwPs,54436
-sfi/pylibpack/rules/numpy.json,sha256=ee4gA5NBudFi3MaJA-QlBKQwiQAUb-eluF8HNVkl7Vk,384
-sfi/pylibpack/rules/pymupdf.json,sha256=Hkzh8dvXKCzKx4aeHbu5E0qwgfbwQxZH2VLtQZzlMO4,153
-sfi/pylibpack/rules/pyqt5.json,sha256=JKGnVSUMfXGR5XK1sbL1F6cAsEhl7hK12QkrulAB00M,374
-sfi/pylibpack/rules/pyside2.json,sha256=uSSteT-3wDohWwQ36Z5mSOaSbxrR4565In4uZj_eR4w,557
-sfi/pylibpack/rules/scipy.json,sha256=vTSi3W5BGWcwMkaDnyD6Yg7ijZdicPEUMw4fnRTnNf4,468
-sfi/pylibpack/rules/shiboken2.json,sha256=9Pl3eslvergyjlyHNknkyN0oZlcH3049WULe5WjsmKM,515
-sfi/pyloadergen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/pyloadergen/pyloadergen.py,sha256=R2E6YBCUwfgT3SLr7paBBYEcuySLaj1q_CTZC2slwWQ,39741
-sfi/pypack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/pypack/pypack.py,sha256=-l3jc4akSSlgEmwiB-kITP0ioBBy42-taHkEsGNEQNw,35168
-sfi/pyprojectparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/pyprojectparse/pyprojectparse.py,sha256=MLDuQm5LFZW-TQ_GfaaeFSa18lsQq5u2ZTjnlkFQ_Ao,19112
-sfi/pysourcepack/pysourcepack.py,sha256=qjBCFnY_3S7xwPgQ2GB0dr0WFbEj3uusZQ_udiU0Bok,9452
-sfi/quizbase/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/quizbase/quizbase.py,sha256=3tPUuYexZ9TVsNPPO_Itmr5OvyHSgY5OSUZwPoQt9zg,30605
-sfi/quizbase/quizbase_gui.py,sha256=7prc5tWkbUPzs1ofNc4xIC_aRrMCWB6RYN_NTq70p0Q,34729
-sfi/regexvalidate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/regexvalidate/regex_help.html,sha256=3ltx3nh-Y5kkbHy5D67KfWtLig3u5XEhIlPHdHLEuTE,12436
-sfi/regexvalidate/regexvalidate.py,sha256=5C_M2EKt9Jlonq03v9zrqtsFfAKK3D1vF1kBxD6iUpE,18600
-sfi/taskkill/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/taskkill/taskkill.py,sha256=kRacCP78mDsZk44tfm4qblOplPxQuo3_6lHl6UQEmkU,7744
-sfi/which/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/which/which.py,sha256=zVIAwZA-pGGngxkkwZ6IxDX3ozVHg7cLSYwYO9FjaIc,2439
-sfi/workflowengine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/workflowengine/workflowengine.py,sha256=ck5PjyyjtWtbjN4ePEKsTWV6QR-BUlrfwrY6jih52jQ,17055
-pysfi-0.1.11.dist-info/METADATA,sha256=4dkuiM92FRkYo-8ti_ZEmAxq1eoFa6HF0xs8ErJyc68,4047
-pysfi-0.1.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pysfi-0.1.11.dist-info/entry_points.txt,sha256=FhBsBY75x9e-AAyJ0t0HD1rb90FDllsM_IdVGHWZx9o,1099
-pysfi-0.1.11.dist-info/RECORD,,