wpipe 2.1.4__tar.gz → 2.2.0__tar.gz

{wpipe-2.1.4 → wpipe-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wpipe
-Version: 2.1.4
+Version: 2.2.0
 Summary: Pipeline library with API integration for task orchestration and execution tracking
 Project-URL: Homepage, https://github.com/wisrovi/wpipe
 Project-URL: Documentation, https://wpipe.readthedocs.io/en/latest/
@@ -81,11 +81,11 @@ Requires-Dist: sphinx-sitemap>=2.5.0; extra == 'docs'
 Requires-Dist: sphinx>=7.2.0; extra == 'docs'
 Description-Content-Type: text/markdown
 
-# 🚀 WPipe v2.1.1
+# 🚀 WPipe v2.2.0
 
 **El motor de orquestación de pipelines más rápido, resiliente y puro para Python.**
 
-WPipe es una librería profesional diseñada para automatizar flujos de trabajo complejos, garantizando que tus datos viajen seguros, tus procesos sean ultra-rápidos y tus fallos sean fáciles de diagnosticar. Incluye ahora un **Tour de Aprendizaje con 130 Niveles** para dominar la librería desde lo más básico hasta lo más avanzado.
+WPipe es una librería profesional diseñada para automatizar flujos de trabajo complejos, garantizando que tus datos viajen seguros, tus procesos sean ultra-rápidos y tus fallos sean fáciles de diagnosticar. Incluye ahora un **Tour de Aprendizaje con 140 Niveles** para dominar la librería desde lo más básico hasta lo más avanzado.
 
 [![PyPI version](https://badge.fury.io/py/wpipe.svg)](https://badge.fury.io/py/wpipe)
 [![Python versions](https://img.shields.io/pypi/pyversions/wpipe.svg)](https://pypi.org/project/wpipe/)
@@ -109,7 +109,7 @@ Diferénciate de los scripts lineales. WPipe te ofrece superpoderes:
 
 ---
 
-## 📊 Features (24 Features)
+## 📊 Features (25 Features)
 
 | Feature | Descripción |
 |---------|-------------|
@@ -138,6 +138,7 @@ Diferénciate de los scripts lineales. WPipe te ofrece superpoderes:
 | 🔄 Async Pipeline | Soporte completo para pipelines asíncronos |
 | 🏗️ DAG Scheduling | Programación basada en grafos acíclicos dirigida |
 | 🌐 Dashboard Web | Dashboard visual en tiempo real |
+| ⚡ **Background Tasks** | Ejecutar tareas sin bloquear el pipeline (fire & forget) |
 
 ---
 
@@ -157,6 +158,7 @@ WPipe se basa en **4 pilares** que puedes combinar libremente:
 
 ```python
 from wpipe import Pipeline, step, Condition, For, Parallel
+from wpipe.pipe.components.logic_blocks import Background
 ```
 
 | Pilar | Uso |
@@ -166,6 +168,7 @@ from wpipe import Pipeline, step, Condition, For, Parallel
 | **`Condition`** | Ramificación condicional basada en expresiones |
 | **`For`** | Bucles con validación de parada |
 | **`Parallel`** | Ejecución paralela de múltiples pasos |
+| **`Background`** | Tareas en background sin bloquear el pipeline |
 
 ### 2. Tu Primer Pipeline
 
@@ -261,7 +264,36 @@ result = pipeline.run({})
 # Las 3 tareas se ejecutan simultáneamente
 ```
 
-### 6. Checkpoints (Resiliencia)
+### 6. Background Tasks (Fire & Forget)
+
+```python
+from wpipe import Pipeline, step
+from wpipe.pipe.components.logic_blocks import Background
+
+@step(name="tarea_principal")
+def tarea_principal(data):
+    print("Ejecutando tarea principal...")
+    return {"status": "completado"}
+
+@step(name="tarea_lenta")
+def tarea_lenta(data):
+    import time
+    print("Enviando telemetría...")
+    time.sleep(2)  # Simula operación lenta
+    print("¡Telemetría enviada!")
+
+pipeline = Pipeline(pipeline_name="con_background")
+pipeline.set_steps([
+    tarea_principal,
+    Background(tarea_lenta),  # No bloquea el pipeline
+])
+
+result = pipeline.run({})
+# El pipeline NO espera 2 segundos, continúa inmediatamente
+# La tarea lenta se ejecuta en background (daemon thread)
+```
+
+### 7. Checkpoints (Resiliencia)
 
 ```python
 from wpipe import Pipeline, step, CheckpointManager
@@ -511,6 +543,19 @@ exporter.export_pipeline_logs(format="json", output_path="reporte.json")
 
 ---
 
+## 📢 Marketing & Community
+
+Hemos expandido nuestra presencia con **+40 nuevos activos de marketing** diseñados para educar y ayudar a los desarrolladores a elegir la mejor arquitectura de orquestación.
+
+- **Dev.to**: Guías técnicas profundas sobre Green-IT y ahorro de RAM.
+- **DZone**: Análisis arquitectónicos sobre resiliencia industrial y estados persistentes.
+- **Reddit**: Historias reales y debates técnicos en comunidades de Python y DevOps.
+- **Indie Hackers**: Estrategias para escalar startups con infraestructura mínima y bajo coste.
+
+Puedes encontrar todos estos materiales en la carpeta `posters/`, numerados del 79 al 121, cubriendo comparativas con Airflow, n8n, Zapier y más.
+
+---
+
 ## DASHBOARD
 
 ### Tutorial

{wpipe-2.1.4 → wpipe-2.2.0}/README.md

@@ -1,8 +1,8 @@
-# 🚀 WPipe v2.1.1
+# 🚀 WPipe v2.2.0
 
 **El motor de orquestación de pipelines más rápido, resiliente y puro para Python.**
 
-WPipe es una librería profesional diseñada para automatizar flujos de trabajo complejos, garantizando que tus datos viajen seguros, tus procesos sean ultra-rápidos y tus fallos sean fáciles de diagnosticar. Incluye ahora un **Tour de Aprendizaje con 130 Niveles** para dominar la librería desde lo más básico hasta lo más avanzado.
+WPipe es una librería profesional diseñada para automatizar flujos de trabajo complejos, garantizando que tus datos viajen seguros, tus procesos sean ultra-rápidos y tus fallos sean fáciles de diagnosticar. Incluye ahora un **Tour de Aprendizaje con 140 Niveles** para dominar la librería desde lo más básico hasta lo más avanzado.
 
 [![PyPI version](https://badge.fury.io/py/wpipe.svg)](https://badge.fury.io/py/wpipe)
 [![Python versions](https://img.shields.io/pypi/pyversions/wpipe.svg)](https://pypi.org/project/wpipe/)
@@ -26,7 +26,7 @@ Diferénciate de los scripts lineales. WPipe te ofrece superpoderes:
 
 ---
 
-## 📊 Features (24 Features)
+## 📊 Features (25 Features)
 
 | Feature | Descripción |
 |---------|-------------|
@@ -55,6 +55,7 @@ Diferénciate de los scripts lineales. WPipe te ofrece superpoderes:
 | 🔄 Async Pipeline | Soporte completo para pipelines asíncronos |
 | 🏗️ DAG Scheduling | Programación basada en grafos acíclicos dirigida |
 | 🌐 Dashboard Web | Dashboard visual en tiempo real |
+| ⚡ **Background Tasks** | Ejecutar tareas sin bloquear el pipeline (fire & forget) |
 
 ---
 
@@ -74,6 +75,7 @@ WPipe se basa en **4 pilares** que puedes combinar libremente:
 
 ```python
 from wpipe import Pipeline, step, Condition, For, Parallel
+from wpipe.pipe.components.logic_blocks import Background
 ```
 
 | Pilar | Uso |
@@ -83,6 +85,7 @@ from wpipe import Pipeline, step, Condition, For, Parallel
 | **`Condition`** | Ramificación condicional basada en expresiones |
 | **`For`** | Bucles con validación de parada |
 | **`Parallel`** | Ejecución paralela de múltiples pasos |
+| **`Background`** | Tareas en background sin bloquear el pipeline |
 
 ### 2. Tu Primer Pipeline
 
@@ -178,7 +181,36 @@ result = pipeline.run({})
 # Las 3 tareas se ejecutan simultáneamente
 ```
 
-### 6. Checkpoints (Resiliencia)
+### 6. Background Tasks (Fire & Forget)
+
+```python
+from wpipe import Pipeline, step
+from wpipe.pipe.components.logic_blocks import Background
+
+@step(name="tarea_principal")
+def tarea_principal(data):
+    print("Ejecutando tarea principal...")
+    return {"status": "completado"}
+
+@step(name="tarea_lenta")
+def tarea_lenta(data):
+    import time
+    print("Enviando telemetría...")
+    time.sleep(2)  # Simula operación lenta
+    print("¡Telemetría enviada!")
+
+pipeline = Pipeline(pipeline_name="con_background")
+pipeline.set_steps([
+    tarea_principal,
+    Background(tarea_lenta),  # No bloquea el pipeline
+])
+
+result = pipeline.run({})
+# El pipeline NO espera 2 segundos, continúa inmediatamente
+# La tarea lenta se ejecuta en background (daemon thread)
+```
+
+### 7. Checkpoints (Resiliencia)
 
 ```python
 from wpipe import Pipeline, step, CheckpointManager
@@ -428,6 +460,19 @@ exporter.export_pipeline_logs(format="json", output_path="reporte.json")
 
 ---
 
+## 📢 Marketing & Community
+
+Hemos expandido nuestra presencia con **+40 nuevos activos de marketing** diseñados para educar y ayudar a los desarrolladores a elegir la mejor arquitectura de orquestación.
+
+- **Dev.to**: Guías técnicas profundas sobre Green-IT y ahorro de RAM.
+- **DZone**: Análisis arquitectónicos sobre resiliencia industrial y estados persistentes.
+- **Reddit**: Historias reales y debates técnicos en comunidades de Python y DevOps.
+- **Indie Hackers**: Estrategias para escalar startups con infraestructura mínima y bajo coste.
+
+Puedes encontrar todos estos materiales en la carpeta `posters/`, numerados del 79 al 121, cubriendo comparativas con Airflow, n8n, Zapier y más.
+
+---
+
 ## DASHBOARD
 
 ### Tutorial

{wpipe-2.1.4 → wpipe-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wpipe"
-version = "2.1.4"
+version = "2.2.0"
 authors = [
     { name = "William Steve Rodriguez Villamizar", email = "wisrovi.rodriguez@gmail.com" }
 ]

wpipe-2.2.0/test/test_background.py

@@ -0,0 +1,252 @@
+"""
+Tests for Background step functionality.
+"""
+
+import pytest
+import time
+import threading
+import asyncio
+import sqlite3
+import threading
+from typing import Dict, Any
+
+from wpipe import Pipeline
+from wpipe.pipe.components.logic_blocks import Background
+
+
+# --- RE-PARCHE DE EMERGENCIA PARA ARREGLAR BUG DE WPIPE ---
+from wsqlite import WSQLite
+_db_connections = {}
+_db_lock = threading.Lock()
+
+def better_get_connection(self):
+    db_path = getattr(self, "db_path", getattr(self, "db_name", "register.db"))
+    with _db_lock:
+        if db_path not in _db_connections:
+            conn = sqlite3.connect(db_path, check_same_thread=False)
+            conn.execute("PRAGMA journal_mode=WAL")
+            _db_connections[db_path] = conn
+        return _db_connections[db_path]
+
+WSQLite._get_connection = better_get_connection
+# --- END RE-PARCHE ---
+
+
+class TestBackgroundStep:
+    """Tests for Background step execution."""
+
+    def test_background_executes_without_blocking(self) -> None:
+        """Background step should execute without blocking the pipeline."""
+        execution_order = []
+        
+        def slow_task(data):
+            time.sleep(0.5)
+            execution_order.append("slow")
+            return {}
+        
+        def fast_task(data):
+            execution_order.append("fast")
+            return {}
+
+        pipeline = Pipeline(verbose=False)
+        pipeline.set_steps([
+            (fast_task, "Fast", "v1.0"),
+            Background(slow_task),
+        ])
+        
+        start = time.time()
+        result = pipeline.run({})
+        elapsed = time.time() - start
+        
+        assert "fast" in execution_order
+        assert elapsed < 0.5, "Pipeline should not wait for background task"
+
+    def test_background_ignores_return(self) -> None:
+        """Background step return should be ignored by pipeline."""
+        def background_step(data):
+            return {"bg_value": "should_be_ignored"}
+        
+        def check_step(data):
+            data["check_executed"] = True
+            return data
+
+        pipeline = Pipeline(verbose=False)
+        pipeline.set_steps([
+            Background(background_step),
+            check_step,
+        ])
+        
+        result = pipeline.run({})
+        
+        assert result.get("check_executed") is True
+        assert "bg_value" not in result, "Background return should be ignored"
+
+    def test_background_failure_without_capture_error(self) -> None:
+        """Background step failure with capture_error=False should not stop pipeline."""
+        def failing_background(data):
+            raise ValueError("Background task failed")
+        
+        def continue_step(data):
+            data["continued"] = True
+            return data
+
+        pipeline = Pipeline(verbose=False)
+        pipeline.set_steps([
+            Background(failing_background, capture_error=False),
+            continue_step,
+        ])
+        
+        result = pipeline.run({})
+        
+        assert result.get("continued") is True, "Pipeline should continue despite background failure"
+
+    def test_background_failure_with_capture_error(self) -> None:
+        """Background step failure with capture_error=True should trigger error handler."""
+        import time
+        error_captured = []
+        
+        def failing_background(data):
+            raise ValueError("Background task failed")
+        
+        def error_handler(data, error_info):
+            error_captured.append(error_info.get("error") or error_info.get("error_message"))
+        
+        def continue_step(data):
+            data["continued"] = True
+            return data
+
+        pipeline = Pipeline(verbose=False)
+        pipeline.add_error_capture([error_handler])
+        pipeline.set_steps([
+            Background(failing_background, capture_error=True),
+            continue_step,
+        ])
+        
+        result = pipeline.run({})
+        time.sleep(0.1)
+        
+        assert result.get("continued") is True
+        assert len(error_captured) > 0
+        assert "Background task failed" in str(error_captured[0]) or "502" in str(error_captured[0])
+
+    def test_background_with_tuple_step(self) -> None:
+        """Background should accept tuple steps (func, name, version)."""
+        import time
+        executed = []
+        
+        def bg_task(data):
+            executed.append(True)
+        
+        def check_task(data):
+            return data
+
+        pipeline = Pipeline(verbose=False)
+        pipeline.set_steps([
+            Background((bg_task, "My Background", "v1.0")),
+            check_task,
+        ])
+        
+        result = pipeline.run({})
+        time.sleep(0.1)
+        
+        assert len(executed) == 1
+
+    def test_multiple_background_steps(self) -> None:
+        """Multiple background steps should all execute."""
+        import time
+        counter = {"value": 0}
+        
+        def increment(data):
+            counter["value"] += 1
+        
+        def check(data):
+            data["counter"] = counter["value"]
+            return data
+
+        pipeline = Pipeline(verbose=False)
+        pipeline.set_steps([
+            Background(increment),
+            Background(increment),
+            Background(increment),
+            check,
+        ])
+        
+        pipeline.run({})
+        time.sleep(0.3)
+        
+        assert counter["value"] == 3
+
+    def test_background_with_data_copy(self) -> None:
+        """Background should receive a copy of data, not the original."""
+        original_data = {}
+        
+        def background_step(data):
+            data["modified_in_bg"] = True
+        
+        def check_step(data):
+            return data
+
+        pipeline = Pipeline(verbose=False)
+        pipeline.set_steps([
+            Background(background_step),
+            check_step,
+        ])
+        
+        result = pipeline.run({"initial": True})
+        
+        assert "modified_in_bg" not in result
+
+
+class TestBackgroundAsync:
+    """Tests for Background step in async pipeline."""
+
+    def test_async_background_executes_without_blocking(self) -> None:
+        """Background step should execute without blocking async pipeline."""
+        from wpipe import PipelineAsync
+        
+        execution_order = []
+        
+        async def slow_async_task(data):
+            await asyncio.sleep(0.3)
+            execution_order.append("slow")
+            return {}
+        
+        async def fast_task(data):
+            execution_order.append("fast")
+            return {}
+
+        pipeline = PipelineAsync(verbose=False)
+        pipeline.set_steps([
+            (fast_task, "Fast", "v1.0"),
+            Background(slow_async_task),
+        ])
+        
+        start = time.time()
+        result = asyncio.run(pipeline.run({}))
+        elapsed = time.time() - start
+        
+        assert "fast" in execution_order
+        assert elapsed < 0.4, f"Async pipeline should not wait for background task (took {elapsed}s)"
+
+    def test_async_background_failure_with_capture(self) -> None:
+        """Async background with capture_error=True should trigger error handler."""
+        from wpipe import PipelineAsync
+        
+        error_captured = []
+        
+        async def failing_background(data):
+            raise ValueError("Async background failed")
+        
+        def error_handler(data, error_info):
+            error_captured.append(error_info.get("error") or error_info.get("error_message"))
+
+        pipeline = PipelineAsync(verbose=False)
+        pipeline.add_error_capture([error_handler])
+        pipeline.set_steps([
+            Background(failing_background, capture_error=True),
+        ])
+        
+        result = asyncio.run(pipeline.run({}))
+        
+        assert len(error_captured) > 0
+        assert "Async background failed" in str(error_captured[0]) or "502" in str(error_captured[0])

{wpipe-2.1.4 → wpipe-2.2.0}/wpipe/pipe/components/logic_blocks.py

@@ -193,6 +193,43 @@ class For:
         return False
 
 
+class Background:
+    """
+    A background task that executes without blocking the pipeline.
+
+    The step runs in a separate thread and the pipeline continues immediately
+    without waiting for completion. The return value is ignored.
+
+    Attributes:
+        step: The step to execute in background (callable or tuple).
+        capture_error: If True and step fails, run error capture handlers.
+    """
+
+    def __init__(self, step: Any, capture_error: bool = False) -> None:
+        """
+        Initialize a Background block.
+
+        Args:
+            step: The step to execute in background (function, class, or tuple).
+            capture_error: Whether to run error handlers if the step fails.
+        """
+        self.step = step
+        self.capture_error: bool = capture_error
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the block to a dictionary for serialization.
+
+        Returns:
+            Dict[str, Any]: Serialized representation of the background block.
+        """
+        return {
+            "type": "background",
+            "capture_error": self.capture_error,
+            "step": _serialize_step(self.step),
+        }
+
+
 class Parallel:
     """
     Represents a parallel execution block in the pipeline.

{wpipe-2.1.4 → wpipe-2.2.0}/wpipe/pipe/pipe.py

@@ -20,7 +20,7 @@ from wpipe.exception.api_error import logger
 from wpipe.tracking import PipelineTracker
 from wpipe.util.utils import clean_for_json
 
-from .components.logic_blocks import Condition, For, Parallel
+from .components.logic_blocks import Background, Condition, For, Parallel
 from .components.metrics import SystemMetricsCollector
 from .components.progress import ProgressManager
 
@@ -520,6 +520,23 @@ class Pipeline(APIClient):
                     max_workers=item.max_workers,
                     use_processes=item.use_processes,
                 ))
+            elif isinstance(item, Background):
+                normalized_step = normalize_step(item.step)
+                if isinstance(normalized_step, tuple):
+                    bg_step = list(normalized_step)
+                    if len(bg_step) >= 4 and isinstance(bg_step[3], dict):
+                        bg_step[3] = {**bg_step[3], "_is_background": True, "_background_capture_error": item.capture_error}
+                    elif len(bg_step) == 3:
+                        bg_step.append({"_is_background": True, "_background_capture_error": item.capture_error})
+                    else:
+                        bg_step = [normalized_step[0], normalized_step[1] if len(normalized_step) > 1 else "background",
+                                   normalized_step[2] if len(normalized_step) > 2 else "v1.0",
+                                   {"_is_background": True, "_background_capture_error": item.capture_error}]
+                else:
+                    name = getattr(normalized_step, "NAME", getattr(normalized_step, "__name__", "background"))
+                    version = getattr(normalized_step, "VERSION", "v1.0")
+                    bg_step = [normalized_step, name, version, {"_is_background": True, "_background_capture_error": item.capture_error}]
+                new_list.append(tuple(bg_step))
             elif isinstance(item, Pipeline):
                 new_list.append((item, item.pipeline_name or "SubPipeline", "v1.0", {}))
             elif callable(item):
@@ -772,6 +789,15 @@ class Pipeline(APIClient):
         if isinstance(item, Parallel):
             return self._execute_parallel(item, data, parent_step_id, parallel_group, **kwargs)
 
+        is_background = False
+        capture_error = False
+        if isinstance(item, tuple) and len(item) >= 4 and isinstance(item[3], dict):
+            is_background = item[3].get("_is_background", False)
+            capture_error = item[3].get("_background_capture_error", False)
+
+        if is_background:
+            return self._execute_background_step(item, data, capture_error, parent_step_id, parallel_group, **kwargs)
+
         return self._execute_task_step(item, data, parent_step_id, parallel_group, **kwargs)
 
     def _execute_parallel(
@@ -859,6 +885,47 @@ class Pipeline(APIClient):
             self._end_step_tracking(tracked_id, data if "error" not in data else None, data.get("error"))
         return data
 
+    def _execute_background_step(
+        self,
+        item: Any,
+        data: Dict[str, Any],
+        capture_error: bool,
+        parent_step_id: Optional[int],
+        parallel_group: Optional[str],
+        **kwargs: Any
+    ) -> Dict[str, Any]:
+        """Execute a background step without blocking the pipeline."""
+        import threading as bg_thread
+        
+        func, name, version, step_id, step_meta = None, "background", "v1.0", None, {}
+        if isinstance(item, tuple):
+            if len(item) >= 2:
+                func, name, version = item[0], item[1], item[2] if len(item) > 2 else "v1.0"
+                if len(item) >= 4 and isinstance(item[3], dict):
+                    step_meta = item[3]
+        elif callable(item):
+            func = item
+            name = getattr(item, "NAME", getattr(item, "__name__", "background"))
+
+        task_data = data.copy()
+        task_data.pop("progress_rich", None)
+
+        def run_background():
+            try:
+                if func:
+                    self._task_invoke(func, name, task_data, parent_step_id=parent_step_id, parallel_group=parallel_group, **kwargs)
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                if capture_error:
+                    error_info = {"step_name": name, "error": str(e), "error_message": str(e)}
+                    self._execute_error_capture(task_data, error_info)
+                if self.verbose:
+                    print(f"[BACKGROUND ERROR] {name}: {e}")
+
+        # Use daemon thread so process can exit without waiting
+        bg_thread.Thread(target=run_background, daemon=True, name=f"wpipe_bg_{name}").start()
+
+        return data
+
     def _execute_task_step(
         self,
         item: Any,

{wpipe-2.1.4 → wpipe-2.2.0}/wpipe/pipe/pipe_async.py

@@ -16,7 +16,8 @@ from wpipe.api_client.api_client import APIClient
 from wpipe.exception import Codes, TaskError
 from wpipe.tracking import PipelineTracker
 
-from .pipe import Condition, Parallel, SystemMetricsCollector
+from .pipe import Background, Condition, Parallel, SystemMetricsCollector
+from .components.logic_blocks import For
 
 
 def _is_async_callable(func: Any) -> bool:
@@ -418,6 +419,15 @@ class PipelineAsync(APIClient):
         if isinstance(item, Parallel):
             return await self._execute_parallel(item, data, parent_step_id, parallel_group, **kwargs)
 
+        is_background = False
+        capture_error = False
+        if isinstance(item, tuple) and len(item) >= 4 and isinstance(item[3], dict):
+            is_background = item[3].get("_is_background", False)
+            capture_error = item[3].get("_background_capture_error", False)
+
+        if is_background:
+            return await self._execute_background_step(item, data, capture_error, parent_step_id, parallel_group, **kwargs)
+
         return await self._execute_task(item, data, parent_step_id, parallel_group, **kwargs)
 
     async def _execute_parallel(
@@ -470,6 +480,54 @@ class PipelineAsync(APIClient):
             self._end_step_tracking(tracked_parallel_id, data if not error_msg else None, error_msg)
         return data
 
+    async def _execute_error_capture(self, data: Dict[str, Any], error_info: Dict[str, Any]) -> None:
+        """Execute error capture handlers."""
+        if not self._error_capture_tasks:
+            return
+
+        if self.verbose:
+            print(f"\n[ERROR CAPTURE] Processing error in state '{error_info.get('step_name', 'unknown')}'...")
+
+        for handler in self._error_capture_tasks:
+            try:
+                if _is_async_callable(handler):
+                    await handler(data, error_info)
+                else:
+                    handler(data, error_info)
+            except Exception:  # pylint: disable=broad-exception-caught
+                pass
+
+    async def _execute_background_step(
+        self,
+        item: Any,
+        data: Dict[str, Any],
+        capture_error: bool,
+        parent_step_id: Optional[int],
+        parallel_group: Optional[str],
+        **kwargs: Any
+    ) -> Dict[str, Any]:
+        """Execute a background step without blocking the pipeline."""
+        func, name, version = None, "background", "v1.0"
+        if isinstance(item, tuple) and len(item) >= 2:
+            func, name, version = item[0], item[1], item[2] if len(item) > 2 else "v1.0"
+
+        task_data = data.copy()
+        task_data.pop("progress_rich", None)
+
+        async def run_background():
+            try:
+                if func:
+                    await self._execute_task(func, task_data, parent_step_id, parallel_group, **kwargs)
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                if capture_error:
+                    error_info = {"step_name": name, "error": str(e)}
+                    await self._execute_error_capture(task_data, error_info)
+                if self.verbose:
+                    print(f"[BACKGROUND ERROR] {name}: {e}")
+
+        asyncio.create_task(run_background())
+        return data
+
     async def _execute_task(
         self,
         item: Any,
@@ -597,4 +655,62 @@ class PipelineAsync(APIClient):
         Args:
             steps: List of steps to be executed.
         """
-        self.tasks_list = steps
+        new_list = []
+
+        def normalize_step(step: Any) -> Any:
+            """Normalize a step tuple to 4 elements (func, name, version, metadata)."""
+            if isinstance(step, tuple):
+                if len(step) == 3 and callable(step[0]):
+                    if isinstance(step[2], dict):
+                        return (step[0], step[1], "v1.0", step[2])
+                    return (step[0], step[1], step[2], {})
+                if len(step) == 2 and callable(step[0]):
+                    return (step[0], step[1], "v1.0", {})
+                if len(step) == 4 and callable(step[0]):
+                    return step
+            return step
+
+        for item in steps:
+            if isinstance(item, Condition):
+                normalized_true = [normalize_step(s) for s in item.branch_true]
+                normalized_false = [normalize_step(s) for s in item.branch_false]
+                new_list.append(Condition(
+                    expression=item.expression,
+                    branch_true=normalized_true,
+                    branch_false=normalized_false,
+                ))
+            elif isinstance(item, For):
+                normalized_steps = [normalize_step(s) for s in item.steps]
+                new_list.append(For(
+                    validation_expression=item.validation_expression,
+                    iterations=item.iterations,
+                    steps=normalized_steps,
+                ))
+            elif isinstance(item, Parallel):
+                normalized_steps = [normalize_step(s) for s in item.steps]
+                new_list.append(Parallel(
+                    steps=normalized_steps,
+                    max_workers=item.max_workers,
+                    use_processes=item.use_processes,
+                ))
+            elif isinstance(item, Background):
+                normalized_step = normalize_step(item.step)
+                if isinstance(normalized_step, tuple):
+                    bg_step = list(normalized_step)
+                else:
+                    name = getattr(normalized_step, "NAME", getattr(normalized_step, "__name__", "background"))
+                    version = getattr(normalized_step, "VERSION", "v1.0")
+                    bg_step = [normalized_step, name, version, {}]
+                bg_step.append({"_is_background": True, "_background_capture_error": item.capture_error})
+                new_list.append(tuple(bg_step))
+            elif callable(item):
+                name = getattr(item, "NAME", getattr(item, "__name__", "unknown"))
+                version = getattr(item, "VERSION", "v1.0")
+                meta = getattr(item, "_wpipe_metadata", {})
+                new_list.append((item, name, version, meta))
+            elif isinstance(item, tuple) and len(item) >= 2 and callable(item[0]):
+                new_list.append(normalize_step(item))
+            else:
+                new_list.append(item)
+
+        self.tasks_list = new_list