puffinflow 2.dev0__py3-none-any.whl

puffinflow/core/resources/requirements.py

@@ -0,0 +1,217 @@
+"""
+Resource requirements and types for PuffinFlow resource management.
+"""
+
+import logging
+from dataclasses import dataclass
+from enum import Flag
+from typing import TYPE_CHECKING, Optional, Union
+
+if TYPE_CHECKING:
+    from ..agent.state import Priority
+
+logger = logging.getLogger(__name__)
+
+
+class ResourceType(Flag):
+    """Resource type flags for specifying required resources."""
+
+    NONE = 0
+    CPU = 1
+    MEMORY = 2
+    IO = 4
+    NETWORK = 8
+    GPU = 16
+
+    # Convenience combination for all resource types
+    ALL = CPU | MEMORY | IO | NETWORK | GPU
+
+
+@dataclass
+class ResourceRequirements:
+    """
+    Specifies resource requirements for agent states.
+
+    This class defines the computational resources needed by an agent state,
+    including CPU, memory, I/O, network, and GPU resources, along with
+    priority and timeout specifications.
+    """
+
+    cpu_units: float = 1.0
+    memory_mb: float = 100.0
+    io_weight: float = 1.0
+    network_weight: float = 1.0
+    gpu_units: float = 0.0
+    priority_boost: int = 0
+    timeout: Optional[float] = None
+    resource_types: ResourceType = ResourceType.ALL
+
+    def __post_init__(self) -> None:
+        """Ensure resource_types is always a valid ResourceType enum."""
+        try:
+            # Validate that it supports bitwise operations
+            try:
+                test_result = self.resource_types & ResourceType.CPU
+                logger.debug(
+                    f"Bitwise test successful: {self.resource_types} & CPU = {test_result}"
+                )
+            except Exception as e:
+                logger.warning(f"Bitwise operation failed: {e}")
+                self._auto_determine_resource_types()
+
+        except Exception as e:
+            logger.error(f"Error in ResourceRequirements.__post_init__: {e}")
+            # Fallback to a safe default
+            object.__setattr__(self, "resource_types", ResourceType.ALL)
+
+    def _auto_determine_resource_types(self) -> None:
+        """Auto-determine resource_types from individual resource amounts."""
+        resource_types = ResourceType.NONE
+
+        if getattr(self, "cpu_units", 0) > 0:
+            resource_types |= ResourceType.CPU
+        if getattr(self, "memory_mb", 0) > 0:
+            resource_types |= ResourceType.MEMORY
+        if getattr(self, "io_weight", 0) > 0:
+            resource_types |= ResourceType.IO
+        if getattr(self, "network_weight", 0) > 0:
+            resource_types |= ResourceType.NETWORK
+        if getattr(self, "gpu_units", 0) > 0:
+            resource_types |= ResourceType.GPU
+
+        # If no specific resources are requested, default to ALL
+        if resource_types == ResourceType.NONE:
+            resource_types = ResourceType.ALL
+
+        # Use object.__setattr__ for dataclass
+        object.__setattr__(self, "resource_types", resource_types)
+        logger.info(f"Auto-determined resource_types: {resource_types}")
+
+    @property
+    def priority(self) -> "Priority":
+        """Get priority level based on priority_boost."""
+        from ..agent.state import Priority
+
+        if self.priority_boost <= 0:
+            return Priority.LOW
+        elif self.priority_boost == 1:
+            return Priority.NORMAL
+        elif self.priority_boost == 2:
+            return Priority.HIGH
+        else:  # priority_boost >= 3
+            return Priority.CRITICAL
+
+    @priority.setter
+    def priority(self, value: Union["Priority", int]) -> None:
+        """Set priority level, updating priority_boost accordingly."""
+        from ..agent.state import Priority
+
+        if isinstance(value, Priority):
+            self.priority_boost = value.value
+        elif isinstance(value, int):
+            self.priority_boost = value
+        else:
+            raise TypeError(f"Priority must be Priority enum or int, got {type(value)}")
+
+
+# Resource attribute mapping for get_resource_amount function
+RESOURCE_ATTRIBUTE_MAPPING = {
+    ResourceType.CPU: "cpu_units",
+    ResourceType.MEMORY: "memory_mb",
+    ResourceType.IO: "io_weight",
+    ResourceType.NETWORK: "network_weight",
+    ResourceType.GPU: "gpu_units",
+}
+
+
+def safe_check_resource_type(
+    requirements: ResourceRequirements, resource_type: ResourceType
+) -> bool:
+    """
+    Safely check if a resource type is requested in requirements.
+
+    Args:
+        requirements: The ResourceRequirements object
+        resource_type: The ResourceType to check
+
+    Returns:
+        True if the resource type is requested, False otherwise
+    """
+    try:
+        # First try the normal bitwise operation
+        return bool(requirements.resource_types & resource_type)
+    except TypeError as e:
+        logger.warning(
+            f"Bitwise operation failed: {e}. Falling back to value comparison."
+        )
+        try:
+            # Fallback to value-based comparison
+            return bool(requirements.resource_types.value & resource_type.value)
+        except Exception as e2:
+            logger.error(
+                f"Fallback comparison also failed: {e2}. Assuming resource is requested."
+            )
+            # If all else fails, check if the individual resource amount is > 0
+            # Direct attribute access to avoid circular dependency
+            if resource_type in RESOURCE_ATTRIBUTE_MAPPING:
+                attr_name = RESOURCE_ATTRIBUTE_MAPPING[resource_type]
+                return getattr(requirements, attr_name, 0.0) > 0
+            return True
+
+
+def get_resource_amount(
+    requirements: ResourceRequirements, resource_type: ResourceType
+) -> float:
+    """
+    Get the amount of a specific resource type from requirements.
+
+    Args:
+        requirements: The ResourceRequirements object
+        resource_type: The ResourceType to get the amount for
+
+    Returns:
+        The amount of the specified resource type, or 0.0 if the resource type is not enabled
+
+    Raises:
+        ValueError: If resource_type is not a single resource type
+    """
+    if resource_type == ResourceType.NONE:
+        return 0.0
+
+    # Check if the resource type is enabled in the requirements
+    if not safe_check_resource_type(requirements, resource_type):
+        return 0.0
+
+    if resource_type == ResourceType.ALL:
+        # Return sum of all resource amounts
+        total = 0.0
+        for rt, attr in RESOURCE_ATTRIBUTE_MAPPING.items():
+            if safe_check_resource_type(requirements, rt):
+                total += getattr(requirements, attr, 0.0)
+        return total
+
+    # Check if it's a single resource type (power of 2, excluding NONE)
+    if (
+        resource_type.value > 0
+        and (resource_type.value & (resource_type.value - 1)) == 0
+        and resource_type in RESOURCE_ATTRIBUTE_MAPPING
+    ):
+        attr_name = RESOURCE_ATTRIBUTE_MAPPING[resource_type]
+        return getattr(requirements, attr_name, 0.0)
+
+    # Handle combined resource types by summing individual types
+    total = 0.0
+    for rt, attr in RESOURCE_ATTRIBUTE_MAPPING.items():
+        try:
+            if (resource_type.value & rt.value) != 0 and safe_check_resource_type(
+                requirements, rt
+            ):
+                total += getattr(requirements, attr, 0.0)
+        except TypeError:
+            # Fallback if 'in' operation fails
+            if (resource_type.value & rt.value) != 0 and safe_check_resource_type(
+                requirements, rt
+            ):
+                total += getattr(requirements, attr, 0.0)
+
+    return total

puffinflow/version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '2.dev0'
+__version_tuple__ = version_tuple = (2, 'dev0')

puffinflow-2.dev0.dist-info/METADATA

@@ -0,0 +1,334 @@
+Metadata-Version: 2.4
+Name: puffinflow
+Version: 2.dev0
+Summary: A powerful Python workflow orchestration framework with advanced resource management and observability
+Author-email: Mohamed Ahmed <mohamed.ahmed.4894@gmail.com>
+Maintainer-email: Mohamed Ahmed <mohamed.ahmed.4894@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/m-ahmed-elbeskeri/puffinflow-main
+Project-URL: Documentation, https://puffinflow.readthedocs.io
+Project-URL: Repository, https://github.com/m-ahmed-elbeskeri/puffinflow-main.git
+Project-URL: Bug Tracker, https://github.com/m-ahmed-elbeskeri/puffinflow-main/issues
+Project-URL: Changelog, https://github.com/m-ahmed-elbeskeri/puffinflow-main/blob/main/CHANGELOG.md
+Project-URL: Funding, https://github.com/sponsors/m-ahmed-elbeskeri
+Keywords: workflow,orchestration,async,state-management,resource-allocation,task-execution,distributed-systems,monitoring,observability,tracing,metrics,coordination
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Systems Administration
+Classifier: Framework :: AsyncIO
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic<3.0.0,>=2.0.0
+Requires-Dist: pydantic-settings<3.0.0,>=2.0.0
+Requires-Dist: structlog>=23.1.0
+Requires-Dist: typing-extensions>=4.8.0; python_version < "3.11"
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: prometheus-client>=0.19.0
+Requires-Dist: psutil>=5.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12.0; extra == "dev"
+Requires-Dist: pytest-benchmark>=4.0.0; extra == "dev"
+Requires-Dist: pytest-timeout>=2.2.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.5.0; extra == "dev"
+Requires-Dist: black>=23.12.0; extra == "dev"
+Requires-Dist: ruff>=0.1.8; extra == "dev"
+Requires-Dist: mypy>=1.8.0; extra == "dev"
+Requires-Dist: types-psutil>=5.9.0; extra == "dev"
+Requires-Dist: pre-commit>=3.6.0; extra == "dev"
+Requires-Dist: tox>=4.11.0; extra == "dev"
+Requires-Dist: coverage[toml]>=7.3.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7.1.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=2.0.0; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints>=1.25.0; extra == "docs"
+Requires-Dist: myst-parser>=2.0.0; extra == "docs"
+Requires-Dist: sphinxcontrib-asyncio>=0.3.0; extra == "docs"
+Provides-Extra: cli
+Requires-Dist: typer[all]>=0.9.0; extra == "cli"
+Requires-Dist: rich>=13.7.0; extra == "cli"
+Requires-Dist: click>=8.1.0; extra == "cli"
+Provides-Extra: observability
+Requires-Dist: prometheus-client>=0.19.0; extra == "observability"
+Requires-Dist: psutil>=5.9.0; extra == "observability"
+Requires-Dist: opentelemetry-api<2.0.0,>=1.23.0; extra == "observability"
+Requires-Dist: opentelemetry-sdk<2.0.0,>=1.23.0; extra == "observability"
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc<2.0.0,>=1.23.0; extra == "observability"
+Requires-Dist: opentelemetry-exporter-jaeger-thrift<2.0.0,>=1.21.0; extra == "observability"
+Requires-Dist: opentelemetry-instrumentation-asyncio<1.0.0,>=0.44b0; extra == "observability"
+Requires-Dist: opentelemetry-instrumentation-logging<1.0.0,>=0.44b0; extra == "observability"
+Requires-Dist: aiohttp>=3.9.0; extra == "observability"
+Requires-Dist: httpx>=0.26.0; extra == "observability"
+Requires-Dist: aiosmtplib>=3.0.0; extra == "observability"
+Requires-Dist: deprecated>=1.2.6; extra == "observability"
+Provides-Extra: monitoring
+Requires-Dist: prometheus-client>=0.19.0; extra == "monitoring"
+Requires-Dist: opentelemetry-api<2.0.0,>=1.23.0; extra == "monitoring"
+Requires-Dist: opentelemetry-sdk<2.0.0,>=1.23.0; extra == "monitoring"
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc<2.0.0,>=1.23.0; extra == "monitoring"
+Requires-Dist: opentelemetry-instrumentation-asyncio<1.0.0,>=0.44b0; extra == "monitoring"
+Provides-Extra: integrations
+Requires-Dist: fastapi>=0.108.0; extra == "integrations"
+Requires-Dist: celery>=5.3.0; extra == "integrations"
+Requires-Dist: kubernetes>=28.0.0; extra == "integrations"
+Requires-Dist: redis>=5.0.0; extra == "integrations"
+Requires-Dist: httpx>=0.26.0; extra == "integrations"
+Requires-Dist: psutil>=5.9.0; extra == "integrations"
+Provides-Extra: performance
+Requires-Dist: pytest-benchmark>=4.0.0; extra == "performance"
+Requires-Dist: memory-profiler>=0.61.0; extra == "performance"
+Requires-Dist: line-profiler>=4.1.0; extra == "performance"
+Requires-Dist: py-spy>=0.3.14; extra == "performance"
+Provides-Extra: security
+Requires-Dist: bandit>=1.7.5; extra == "security"
+Requires-Dist: safety>=2.3.0; extra == "security"
+Requires-Dist: semgrep>=1.45.0; extra == "security"
+Provides-Extra: all
+Requires-Dist: typer[all]>=0.9.0; extra == "all"
+Requires-Dist: rich>=13.7.0; extra == "all"
+Requires-Dist: click>=8.1.0; extra == "all"
+Requires-Dist: prometheus-client>=0.19.0; extra == "all"
+Requires-Dist: psutil>=5.9.0; extra == "all"
+Requires-Dist: opentelemetry-api<2.0.0,>=1.23.0; extra == "all"
+Requires-Dist: opentelemetry-sdk<2.0.0,>=1.23.0; extra == "all"
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc<2.0.0,>=1.23.0; extra == "all"
+Requires-Dist: opentelemetry-exporter-jaeger-thrift<2.0.0,>=1.21.0; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-asyncio<1.0.0,>=0.44b0; extra == "all"
+Requires-Dist: opentelemetry-instrumentation-logging<1.0.0,>=0.44b0; extra == "all"
+Requires-Dist: aiohttp>=3.9.0; extra == "all"
+Requires-Dist: httpx>=0.26.0; extra == "all"
+Requires-Dist: aiosmtplib>=3.0.0; extra == "all"
+Requires-Dist: fastapi>=0.108.0; extra == "all"
+Requires-Dist: celery>=5.3.0; extra == "all"
+Requires-Dist: kubernetes>=28.0.0; extra == "all"
+Requires-Dist: redis>=5.0.0; extra == "all"
+Dynamic: license-file
+
+# 🐧 PuffinFlow
+
+[![PyPI version](https://badge.fury.io/py/puffinflow.svg)](https://badge.fury.io/py/puffinflow)
+[![Python versions](https://img.shields.io/pypi/pyversions/puffinflow.svg)](https://pypi.org/project/puffinflow/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**PuffinFlow is a powerful Python framework for developers who need to rapidly prototype LLM workflows and seamlessly transition them to production-ready systems.**
+
+Perfect for AI engineers, data scientists, and backend developers who want to focus on workflow logic rather than infrastructure complexity.
+
+## Get started
+
+Install PuffinFlow:
+
+```bash
+pip install puffinflow
+```
+
+Then, create an agent using the state decorator:
+
+```python
+from puffinflow import Agent, state
+
+class DataProcessor(Agent):
+    @state(cpu=2.0, memory=1024.0)
+    async def fetch_data(self, context):
+        """Fetch data from external source."""
+        data = await get_external_data()
+        context.set_variable("raw_data", data)
+        return "validate_data" if data else "error"
+
+    @state(cpu=1.0, memory=512.0)
+    async def validate_data(self, context):
+        """Validate the fetched data."""
+        data = context.get_variable("raw_data")
+        if self.is_valid(data):
+            return "process_data"
+        return "error"
+
+    @state(cpu=4.0, memory=2048.0)
+    async def process_data(self, context):
+        """Process the validated data."""
+        data = context.get_variable("raw_data")
+        result = await self.transform_data(data)
+        context.set_output("processed_data", result)
+        return "complete"
+
+# Run the agent
+agent = DataProcessor("data-processor")
+result = await agent.run()
+```
+
+For more information, see the [Quickstart](https://puffinflow.readthedocs.io/en/latest/guides/quickstart.html). Or, to learn how to build complex multi-agent workflows with coordination and observability, see the [Advanced Examples](./examples/).
+
+## Core benefits
+
+PuffinFlow bridges the gap between quick prototyping and production deployment. Start building your LLM workflow in minutes, then scale to production without rewriting code:
+
+**Prototype to Production**: Begin with simple agents and seamlessly add resource management, observability, and coordination as your needs grow.
+
+**Intelligent resource management**: Automatically allocate and manage CPU, memory, and other resources based on state requirements with built-in quotas and limits.
+
+**Zero-config observability**: Comprehensive monitoring with OpenTelemetry integration, custom metrics, distributed tracing, and real-time alerting that works out of the box.
+
+**Built-in reliability**: Circuit breakers, bulkheads, and leak detection ensure robust operation under various failure conditions without additional configuration.
+
+**Agent coordination**: Scale from single agents to complex multi-agent workflows with teams, pools, and orchestrators using the same simple API.
+
+**Production performance**: Achieve 567,000+ operations/second with sub-millisecond latency, designed for real-world production workloads.
+
+## PuffinFlow's ecosystem
+
+While PuffinFlow can be used standalone, it integrates with popular Python frameworks and tools:
+
+**FastAPI & Django** — Seamlessly integrate PuffinFlow agents into web applications with built-in async support and resource management.
+
+**Celery & Redis** — Enhance existing task queues with stateful workflows, advanced coordination, and comprehensive monitoring.
+
+**OpenTelemetry** — Full observability stack with distributed tracing, metrics collection, and integration with monitoring platforms like Prometheus and Jaeger.
+
+**Kubernetes** — Production-ready deployment with container orchestration, automatic scaling, and cloud-native observability.
+
+## Additional resources
+
+- **[Documentation](https://puffinflow.readthedocs.io/)**: Complete guides and API reference
+- **[Examples](./examples/)**: Ready-to-run code examples for common patterns
+- **[Advanced Guides](./docs/source/guides/)**: Deep dives into resource management, coordination, and observability
+- **[Benchmarks](./benchmarks/)**: Performance metrics and optimization guides
+
+---
+
+## Real-World Examples
+
+### 🔥 Image Processing Pipeline
+```python
+class ImageProcessor(Agent):
+    @state(cpu=2.0, memory=1024.0)
+    async def resize_image(self, context):
+        image_url = context.get_variable("image_url")
+        resized = await resize_image(image_url, size=(800, 600))
+        context.set_variable("resized_image", resized)
+        return "add_watermark"
+
+    @state(cpu=1.0, memory=512.0)
+    async def add_watermark(self, context):
+        image = context.get_variable("resized_image")
+        watermarked = await add_watermark(image)
+        context.set_variable("final_image", watermarked)
+        return "upload_to_storage"
+
+    @state(cpu=1.0, memory=256.0)
+    async def upload_to_storage(self, context):
+        image = context.get_variable("final_image")
+        url = await upload_to_s3(image)
+        context.set_output("result_url", url)
+        return "complete"
+```
+
+### 🤖 ML Model Training
+```python
+class MLTrainer(Agent):
+    @state(cpu=8.0, memory=4096.0)
+    async def train_model(self, context):
+        dataset = context.get_variable("dataset")
+        model = await train_neural_network(dataset)
+        context.set_variable("model", model)
+        context.set_output("accuracy", model.accuracy)
+
+        if model.accuracy > 0.9:
+            return "deploy_model"
+        return "retrain_with_more_data"
+
+    @state(cpu=2.0, memory=1024.0)
+    async def deploy_model(self, context):
+        model = context.get_variable("model")
+        await deploy_to_production(model)
+        context.set_output("deployment_status", "success")
+        return "complete"
+```
+
+### 🔄 Multi-Agent Coordination
+```python
+from puffinflow import create_team, AgentTeam
+
+# Coordinate multiple agents
+email_team = create_team([
+    EmailValidator("validator"),
+    EmailProcessor("processor"),
+    EmailTracker("tracker")
+])
+
+# Execute with built-in coordination
+result = await email_team.execute_parallel()
+```
+
+---
+
+## 🎯 Use Cases
+
+**📊 Data Pipelines** — Build resilient ETL workflows with automatic retries, resource management, and comprehensive monitoring.
+
+**🤖 ML Workflows** — Orchestrate training pipelines, model deployment, and inference workflows with checkpointing and observability.
+
+**🌐 Microservices** — Coordinate distributed services with circuit breakers, bulkheads, and intelligent load balancing.
+
+**⚡ Event Processing** — Handle high-throughput event streams with backpressure control and automatic scaling.
+
+## 📊 Performance
+
+PuffinFlow is built for production workloads with excellent performance characteristics:
+
+### Core Performance Metrics
+- **567,000+ operations/second** for basic agent operations
+- **27,000+ operations/second** for complex data processing
+- **1,100+ operations/second** for CPU-intensive tasks
+- **Sub-millisecond** state transition latency (0.00-1.97ms range)
+
+### Benchmark Results (Latest)
+| Operation Type | Avg Latency | Throughput | Use Case |
+|---|---|---|---|
+| Agent State Transitions | 0.00ms | 567,526 ops/s | Basic workflow steps |
+| Data Processing | 0.04ms | 27,974 ops/s | ETL operations |
+| Resource Management | 0.01ms | 104,719 ops/s | Memory/CPU allocation |
+| Async Coordination | 1.23ms | 811 ops/s | Multi-agent workflows |
+| CPU-Intensive Tasks | 0.91ms | 1,100 ops/s | ML training steps |
+
+*Benchmarks run on: Linux WSL2, 16 cores, 3.68GB RAM, Python 3.12*
+
+[View detailed benchmarks →](./benchmarks/)
+
+## 🤝 Community & Support
+
+- **[🐛 Issues](https://github.com/m-ahmed-elbeskeri/puffinflow/issues)** — Bug reports and feature requests
+- **[💬 Discussions](https://github.com/m-ahmed-elbeskeri/puffinflow/discussions)** — Community Q&A
+- **[📧 Email](mailto:mohamed.ahmed.4894@gmail.com)** — Direct contact for support
+
+## Acknowledgements
+
+PuffinFlow is inspired by workflow orchestration principles and builds upon the Python async ecosystem. The framework emphasizes practical workflow management with production-ready features. PuffinFlow is built by Mohamed Ahmed, designed for developers who need reliable, observable, and scalable workflow orchestration.
+
+## 📜 License
+
+PuffinFlow is released under the [MIT License](LICENSE). Free for commercial and personal use.
+
+---
+
+<div align="center">
+
+**Ready to build production-ready workflows?**
+
+[Get Started →](https://puffinflow.readthedocs.io/en/latest/guides/quickstart.html) | [View Examples →](./examples/) | [Join Community →](https://github.com/m-ahmed-elbeskeri/puffinflow/discussions)
+
+</div>

puffinflow-2.dev0.dist-info/RECORD

@@ -0,0 +1,55 @@
+puffinflow/__init__.py,sha256=UnuscpJdtuwzB9i9m8zbZ-oQWLJWgM-4_TQeXGCy-b0,2623
+puffinflow/version.py,sha256=h4IuJsX5bQcAuFjGgJgLghhjV7tMYP_AObu5mYfUkFo,514
+puffinflow/core/__init__.py,sha256=ky3V0ulDLGExVSBGtCOSw91ulX3TohSDs1czkYIZHb0,3584
+puffinflow/core/config.py,sha256=00ks86HgALGfBGWKoHarEHd8st1RKn-B3D_L5ilShq8,1952
+puffinflow/core/agent/__init__.py,sha256=AFrdpn1UV6fUh19dRg5IDN555nwk8CVXDf8O1usMRMI,8522
+puffinflow/core/agent/base.py,sha256=uXlEkoRcOYf-xwydu9uWOkv0NSUDZUAcSw_alRNPo-c,62386
+puffinflow/core/agent/checkpoint.py,sha256=E3OZMogJ0omMtZI_coeTjRvu8TmqS8DmUMGpqGUclnY,1492
+puffinflow/core/agent/context.py,sha256=KJnrcePY5HZMQCYTD8wrlKF_uJx6gOorUYMDBZoNcfw,18477
+puffinflow/core/agent/dependencies.py,sha256=6LgR98bFs8BFt6CIRwA_auKm_7deOkGCam6pd3dxJYQ,1978
+puffinflow/core/agent/state.py,sha256=2b7nFTxTM-oEKfNkYhThHF-IKvBc0aNTKnd6hehRK0I,3517
+puffinflow/core/agent/decorators/__init__.py,sha256=zyL2L9TFGukFB3KwaQZNY6DW_PrwssAdIYsW4aZHN9Q,2073
+puffinflow/core/agent/decorators/builder.py,sha256=XZ7D7tYRIVO-qZdY0vS1KXdv6q85Qr4zj23zASfm7Eg,14656
+puffinflow/core/agent/decorators/flexible.py,sha256=nGzMU3la6qnu9ePCXNTm7fu5XL0na_CrHZvQXiFctls,25921
+puffinflow/core/agent/decorators/inspection.py,sha256=4oxEjcanc_wz8bW9O2eBlEACCMviag9r0aqxQD5mRUI,4844
+puffinflow/core/agent/scheduling/__init__.py,sha256=JFJgqhrMa0aid_xHgZkCgoJbPEHL58CVsTugELxZmp4,627
+puffinflow/core/agent/scheduling/builder.py,sha256=gNYDNaqYezb-8NbEbXlFEt_7zFZ_K76MODGZF4_EMeA,5077
+puffinflow/core/agent/scheduling/exceptions.py,sha256=3IAWd3QAJ7uh20xBbmla7QGNVbNXYT2V-BzKbzVbE64,1013
+puffinflow/core/agent/scheduling/inputs.py,sha256=o_CHJchV504fQs3yO1POgMIcRAgeU2-er31M5ba5KpQ,4490
+puffinflow/core/agent/scheduling/parser.py,sha256=wovziX-KqdvhozncJOEw0OfEqIaDsPLvaNdTLsfqXV4,7373
+puffinflow/core/agent/scheduling/scheduler.py,sha256=y-2erkDoguy4Yl87tXG1TaVw6ZhQvrNadrxugiYUWMA,13771
+puffinflow/core/coordination/__init__.py,sha256=pGYDH0QJt9z3YUivhTSKmNCE3QC1XugCoGs1J2OE12A,2921
+puffinflow/core/coordination/agent_group.py,sha256=OtEzLBkGRbV6z9gBbrN6kD58hA6vqYhJ55L5U54iCpU,11962
+puffinflow/core/coordination/agent_pool.py,sha256=x6ldfzvcymIUXavbmLMlfC71_J2h2J36H7_goifpSEA,22772
+puffinflow/core/coordination/agent_team.py,sha256=gQAVTuELq0W3lcwPMKAcyCl5AAySFCE8YUn7WxB-BFk,19516
+puffinflow/core/coordination/coordinator.py,sha256=s2OCb6D1Jv49qghD--lEHupr6fgqTCrSiW7o4WoCf-k,26788
+puffinflow/core/coordination/deadlock.py,sha256=QfOBJzzYoSx7_AIE2Pd_-IUcel6WGnr_n0u-z2Yr43c,64950
+puffinflow/core/coordination/fluent_api.py,sha256=kY8hzY0Mp8qcvO7O7soHTdnEVbMiw09lW8PvGdL2suc,14896
+puffinflow/core/coordination/primitives.py,sha256=nIEJkAp4qRpiQWMUYAfQDu988rcc7q_fidoDWYbMmvk,16634
+puffinflow/core/coordination/rate_limiter.py,sha256=0-xHAl8n2-BdrqRGwRX18dG73faXhqSyrzMuB5FTPaE,17692
+puffinflow/core/observability/__init__.py,sha256=7ldAw323pmhmbv9P4ctYlpETHhniMohv-GD93gbhcSY,1045
+puffinflow/core/observability/agent.py,sha256=bUjGbQmfYaSfFLwQ6zRKG2VceXKxAtQliRG7pGBpH7w,5087
+puffinflow/core/observability/alerting.py,sha256=YtFp5y9LhEHkzkihMPWTb7WFUUf6bvpbMefKmMD4H34,2123
+puffinflow/core/observability/config.py,sha256=EScIvDHJuKiyR0FH11eLXpyND_oyAzG-Kgkx1zJXCEw,4296
+puffinflow/core/observability/context.py,sha256=vRxwyRDDzuW59Bn7RteSltTf-tgaJevwme5qsj-Amks,2932
+puffinflow/core/observability/core.py,sha256=LKo_d8O3G-Nh1RZsjWIN9th7x6bLYQ--icoPWfa19SM,4654
+puffinflow/core/observability/decorators.py,sha256=XOiQgsEfc3HDA8FETR1vq1M_xICs0qLZ41TEBOwOPhU,3820
+puffinflow/core/observability/events.py,sha256=4SWO3DjTjRT4yp3SiDQSPqr5TkDeMxryRiL8ljSkE2A,2525
+puffinflow/core/observability/interfaces.py,sha256=LPofmDp4wUw6-Ls8MgI2SnaQj-FgwCV8GXptw405ep0,4897
+puffinflow/core/observability/metrics.py,sha256=tJnCuREaKwL1wXnpF2qjoAmmJKk4S58pVNR9_QSd620,5139
+puffinflow/core/observability/tracing.py,sha256=xWyTy0uA_CDElORkrdfmBTsDP5EUZmNsehkLjCvz6sY,7403
+puffinflow/core/reliability/__init__.py,sha256=N48Hn2JcJQgM3JzMpBU9bdTWFihH7PU7ZXLCpFx_zvk,684
+puffinflow/core/reliability/bulkhead.py,sha256=JE7G6W2V3gggeZ9pipO_W4h_y4YhYOH23a-uvHAAsbs,2895
+puffinflow/core/reliability/circuit_breaker.py,sha256=jWiWowX08ORoJ7OSgBZuN0BLIgLhthYe_lA2vWUp1rU,4735
+puffinflow/core/reliability/leak_detector.py,sha256=z31u2lvO82EfE6eyzAhFOsFaA6MPctsIhKKT0kEtwuA,4089
+puffinflow/core/resources/__init__.py,sha256=wpq1n83Hjr1Ua1DsSlvaZcZbwLvYmhlrb-phBQ038gU,1722
+puffinflow/core/resources/allocation.py,sha256=mZGBLvk6bmOOU8X_I-U2_6rAS1SrFCYztzx513seZ1E,28851
+puffinflow/core/resources/pool.py,sha256=7KkC66c2Y04yUsq6-1O4dl8MGOdrCUzFyGof9kv61uo,24394
+puffinflow/core/resources/quotas.py,sha256=1377rf00LqIVZuuwq7jxat8aFLwZ8i5WgZSD8766-CA,18159
+puffinflow/core/resources/requirements.py,sha256=7J07JVIqa1sL9v-xCC-aGQjS2Vtk9Fwliajp8fOJNRE,7428
+puffinflow-2.dev0.dist-info/licenses/LICENSE,sha256=_iTSa1NhJHVNdoCwmNMrS3nVUTwnEcflmb8zcplrm_g,1067
+puffinflow-2.dev0.dist-info/METADATA,sha256=v1v_K-GCrqfo06io3jZF3cXPJyj8nNGLUoeOA_3NEIU,15172
+puffinflow-2.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+puffinflow-2.dev0.dist-info/entry_points.txt,sha256=kFo-w_DMoIAb-mlBdkE4Rp1sBNQ-rosnI0yFLdTfYaI,113
+puffinflow-2.dev0.dist-info/top_level.txt,sha256=76A_vroRA-4hO5-lugaSXM8BSKuWS5f4uIlqPKohiZs,11
+puffinflow-2.dev0.dist-info/RECORD,,

puffinflow-2.dev0.dist-info/WHEEL

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

puffinflow-2.dev0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+puffinflow = puffinflow.cli.main:app
+puffinflow-benchmark = benchmarks.run_all_benchmarks:main

puffinflow-2.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 PuffinFlow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

puffinflow-2.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+puffinflow