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

sfi/pysourcepack/pysourcepack.py

@@ -118,7 +118,6 @@ class ProjectPacker:
 
     parent: PySourcePacker
     project: Project
-    project_name: str
     include_patterns: set[str]
     exclude_patterns: set[str]
 
@@ -130,16 +129,13 @@ class ProjectPacker:
     @cached_property
     def project_path(self) -> Path:
         """Get project directory path."""
-        return (
-            self.parent.root_dir
-            if self.is_single_project
-            else self.parent.root_dir / self.project_name
-        )
+        # Use the actual directory from toml_path instead of project name
+        return self.project.toml_path.parent
 
     @cached_property
     def output_dir(self) -> Path:
         """Get output directory path."""
-        return self.parent.root_dir / "dist" / "src" / self.project_name
+        return self.parent.root_dir / "dist" / "src" / self.project.normalized_name
 
     def validate_project_path(self) -> bool:
         """Validate project path exists and is a directory."""
@@ -159,14 +155,14 @@ class ProjectPacker:
         Returns:
             True if packing succeeded, False otherwise
         """
-        logger.debug(f"Start packing project: {self.project_name}")
+        logger.debug(f"Start packing project: {self.project.normalized_name}")
 
-        if not self.project_name:
+        if not self.project.normalized_name:
             logger.error("Project name cannot be empty")
             return False
 
         logger.debug(
-            f"Project path: {self.project_path}, project_name: {self.project_name}"
+            f"Project path: {self.project_path}, project_name: {self.project.normalized_name}"
         )
         if not self.validate_project_path():
             return False
@@ -177,7 +173,9 @@ class ProjectPacker:
         copied_files = 0
         copied_dirs = 0
 
-        logger.info(f"Packing project '{self.project_name}' to {self.output_dir}")
+        logger.info(
+            f"Packing project '{self.project.normalized_name}' to {self.output_dir}"
+        )
 
         try:
             for item in self.project_path.iterdir():
@@ -202,12 +200,12 @@ class ProjectPacker:
                     copied_dirs += 1
 
             logger.info(
-                f"Successfully packed {self.project_name}: {copied_files} files, {copied_dirs} directories"
+                f"Successfully packed {self.project.normalized_name}: {copied_files} files, {copied_dirs} directories"
             )
             return True
 
         except Exception as e:
-            logger.error(f"Error packing project {self.project_name}: {e}")
+            logger.error(f"Error packing project {self.project.normalized_name}: {e}")
             return False
 
 
@@ -248,7 +246,6 @@ class PySourcePacker:
         packer = ProjectPacker(
             parent=self,
             project=project,
-            project_name=project_name,
             include_patterns=self.include_patterns,
             exclude_patterns=self.exclude_patterns,
         )

sfi/workflowengine/workflowengine.py

@@ -1,547 +0,0 @@
-"""Workflow Engine - A flexible async task orchestration system.
-
-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
-
-import asyncio
-import time
-from abc import ABC, abstractmethod
-from collections import defaultdict, deque
-from dataclasses import dataclass
-from enum import Enum
-from typing import Any, Callable, Sequence
-
-
-class TaskStatus(Enum):
-    """Task status enumeration"""
-
-    PENDING = "pending"
-    READY = "ready"
-    RUNNING = "running"
-    COMPLETED = "completed"
-    FAILED = "failed"
-
-
-class TaskType(Enum):
-    """Task type enumeration"""
-
-    SERIAL = "serial"  # Serial task
-    PARALLEL = "parallel"  # Parallel task
-    ASYNC = "async"  # Async I/O task
-    CPU = "cpu"  # CPU-intensive task
-
-
-@dataclass
-class TaskResult:
-    """Task execution result"""
-
-    task_id: str
-    success: bool
-    data: Any
-    execution_time: float
-    error: Exception | None = None
-
-
-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,
-    ):
-        self.task_id = task_id
-        self.task_type = task_type
-        self.dependencies = dependencies or []
-        self.timeout = timeout
-        self.status = TaskStatus.PENDING
-        self.result: TaskResult | None = None
-        self.start_time: float | None = None
-        self.end_time: float | None = None
-
-    def get_dependencies(self) -> list[str]:
-        """Get list of dependent task IDs"""
-        return self.dependencies.copy()
-
-    def can_execute(self, completed_tasks: set[str]) -> bool:
-        """Check if task can be executed (dependencies satisfied)"""
-        return all(dep in completed_tasks for dep in self.dependencies)
-
-    def update_status(self, status: TaskStatus):
-        """Update task status"""
-        self.status = status
-
-    @abstractmethod
-    async def execute(self, context: dict[str, TaskResult]) -> Any:
-        """Execute task logic, must be implemented by subclasses"""
-        pass
-
-    def get_execution_time(self) -> float:
-        """Get task execution time"""
-        if self.start_time and self.end_time:
-            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,
-    ):
-        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"
-        )
-        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"""
-        await asyncio.sleep(self.duration)
-        return f"IO task {self.task_id} completed, dependencies: {list(context.keys())}"
-
-
-class CPUTask(Task):
-    """CPU-intensive task"""
-
-    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"""
-
-        def cpu_intensive_work():
-            result = 0
-            for i in range(self.iterations):
-                result += i * i
-            return result
-
-        # Use run_in_executor to avoid blocking event loop
-        loop = asyncio.get_event_loop()
-        result = await loop.run_in_executor(None, cpu_intensive_work)
-        return f"CPU task {self.task_id} completed, result: {result}"
-
-
-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,
-    ):
-        super().__init__(task_id, TaskType.SERIAL, dependencies, timeout)
-        self.process_func = process_func
-        self.state = {}
-
-    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}
-
-        # Execute process function
-        if asyncio.iscoroutinefunction(self.process_func):
-            result = await self.process_func(inputs, self.state)
-        else:
-            result = self.process_func(inputs, self.state)
-
-        # Update state
-        self.state = {"last_result": result, "executed": True}
-
-        return f"Serial task {self.task_id} completed, result: {result}"
-
-
-class ParallelTask(Task):
-    """Parallel task (can execute concurrently with other tasks)"""
-
-    def __init__(
-        self,
-        task_id: str,
-        subtasks: Sequence[Task],
-        dependencies: list[str] | None = None,
-        timeout: float = 30.0,
-        max_concurrent: int = 3,
-    ):
-        super().__init__(task_id, TaskType.PARALLEL, dependencies, timeout)
-        self.subtasks = subtasks
-        self.max_concurrent = max_concurrent
-
-    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"
-        )
-        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_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
-                    )
-                    subtask.result = TaskResult(
-                        task_id=subtask.task_id,
-                        success=True,
-                        data=data,
-                        execution_time=time.time() - subtask.start_time
-                        if subtask.start_time
-                        else 0,
-                    )
-                    subtask.update_status(TaskStatus.COMPLETED)
-                    return subtask.result
-                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
-                        if subtask.start_time
-                        else 0,
-                        error=e,
-                    )
-                    subtask.update_status(TaskStatus.FAILED)
-                    return subtask.result
-
-        # Execute all subtasks in parallel
-        results = await asyncio.gather(
-            *[execute_subtask_with_semaphore(subtask) for subtask in self.subtasks],
-            return_exceptions=True,
-        )
-
-        # Process results
-        successful_results = []
-        failed_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):
-                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}"
-
-        return f"Parallel task {self.task_id} completed, results: {successful_results}"
-
-
-class WorkflowEngine:
-    """Workflow engine - core orchestrator"""
-
-    def __init__(self, max_concurrent: int = 4):
-        self.tasks: dict[str, Task] = {}
-        self.results: dict[str, TaskResult] = {}
-        self.max_concurrent = max_concurrent
-        self.execution_order: list[list[str]] = []
-
-    def add_task(self, task: Task):
-        """Add task to workflow"""
-        self.tasks[task.task_id] = task
-
-    def validate_dependencies(self) -> bool:
-        """Validate task dependencies, ensure no circular dependencies"""
-        # Build adjacency list
-        graph = defaultdict(list)
-        in_degree = dict.fromkeys(self.tasks, 0)
-
-        for task_id, task in self.tasks.items():
-            for dep in task.get_dependencies():
-                if dep not in self.tasks:
-                    raise ValueError(f"Task {task_id} depends on unknown task {dep}")
-                graph[dep].append(task_id)
-                in_degree[task_id] += 1
-
-        # Detect circular dependencies
-        visited = 0
-        queue = deque([task_id for task_id, degree in in_degree.items() if degree == 0])
-
-        while queue:
-            current = queue.popleft()
-            visited += 1
-
-            for neighbor in graph[current]:
-                in_degree[neighbor] -= 1
-                if in_degree[neighbor] == 0:
-                    queue.append(neighbor)
-
-        if visited != len(self.tasks):
-            raise ValueError("Circular dependency detected in workflow")
-
-        return True
-
-    def calculate_execution_order(self) -> list[list[str]]:
-        """Calculate task execution order (topological sort + level grouping)"""
-        if not self.tasks:
-            return []
-
-        # Build adjacency list
-        graph = defaultdict(list)
-        in_degree = dict.fromkeys(self.tasks, 0)
-
-        for task_id, task in self.tasks.items():
-            for dep in task.get_dependencies():
-                graph[dep].append(task_id)
-                in_degree[task_id] += 1
-
-        # Level-based topological sort
-        execution_order = []
-        queue = deque([task_id for task_id, degree in in_degree.items() if degree == 0])
-
-        while queue:
-            level_size = len(queue)
-            current_level = []
-
-            for _ in range(level_size):
-                task_id = queue.popleft()
-                current_level.append(task_id)
-
-                for neighbor in graph[task_id]:
-                    in_degree[neighbor] -= 1
-                    if in_degree[neighbor] == 0:
-                        queue.append(neighbor)
-
-            if current_level:
-                execution_order.append(current_level)
-
-        self.execution_order = execution_order
-        return execution_order
-
-    async def execute_workflow(self) -> dict[str, TaskResult]:
-        """Execute entire workflow"""
-        print("=" * 50)
-        print("Starting workflow execution")
-        print("=" * 50)
-
-        # Validate dependencies
-        self.validate_dependencies()
-
-        # Calculate execution order
-        execution_order = self.calculate_execution_order()
-        print(f"Execution plan ({len(execution_order)} phases):")
-        for i, level in enumerate(execution_order, 1):
-            print(f"  Phase {i}: {level}")
-
-        # Execute by level
-        completed_tasks: set[str] = set()
-
-        for level_index, level in enumerate(execution_order, 1):
-            print(f"\n{'=' * 20} Phase {level_index} ({len(level)} tasks) {'=' * 20}")
-
-            # Execute the current level
-            await self._execute_level(level, completed_tasks)
-
-        print(f"\n{'=' * 50}")
-        print("Workflow execution completed")
-        print(f"{'=' * 50}")
-
-        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)
-        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": pending,
-            "total_execution_time": total_time,
-            "success_rate": success_rate,
-        }