quantumflow-sdk 0.1.0__tar.gz → 0.2.1__tar.gz

{quantumflow_sdk-0.1.0 → quantumflow_sdk-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantumflow-sdk
-Version: 0.1.0
+Version: 0.2.1
 Summary: Quantum-optimized AI agent workflow platform with 53% token compression
 Author-email: BlockQuantAI <hello@blockquant.ai>
 License-Expression: MIT

{quantumflow_sdk-0.1.0 → quantumflow_sdk-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quantumflow-sdk"
-version = "0.1.0"
+version = "0.2.1"
 description = "Quantum-optimized AI agent workflow platform with 53% token compression"
 readme = "README.md"
 license = "MIT"

{quantumflow_sdk-0.1.0 → quantumflow_sdk-0.2.1}/src/quantumflow/__init__.py

@@ -6,10 +6,11 @@ Core Features:
 - O(log n) memory through quantum entanglement
 - Quantum teleportation for secure messaging
 - BB84 QKD for unconditionally secure key exchange
+- Workflow orchestration for chaining quantum operations
 - Multi-backend support (IBM, AWS Braket, Simulator)
 
 Installation:
-    pip install quantumflow
+    pip install quantumflow-sdk
 
 Quick Start:
     from quantumflow import QuantumCompressor
@@ -17,6 +18,14 @@ Quick Start:
     compressor = QuantumCompressor(backend="simulator")
     result = compressor.compress([100, 200, 150, 175])
     print(f"Compression: {result.compression_percentage}%")
+
+Workflow Example:
+    from quantumflow import QuantumWorkflow
+
+    workflow = QuantumWorkflow()
+    workflow.add_step("compress", params={"tokens": [100, 200, 150]})
+    workflow.add_step("qkd", params={"key_length": 256})
+    result = workflow.execute()
 """
 
 from quantumflow.core.quantum_compressor import QuantumCompressor, CompressedResult
@@ -28,8 +37,9 @@ from quantumflow.core.teleportation import (
     QKDExchange,
     SecureMessenger,
 )
+from quantumflow.core.workflow import QuantumWorkflow, WorkflowResult
 
-__version__ = "0.1.0"
+__version__ = "0.2.1"
 __all__ = [
     # Core compression
     "QuantumCompressor",
@@ -44,4 +54,7 @@ __all__ = [
     "QuantumTeleporter",
     "QKDExchange",
     "SecureMessenger",
+    # Workflow
+    "QuantumWorkflow",
+    "WorkflowResult",
 ]

quantumflow_sdk-0.2.1/src/quantumflow/api/routes/__init__.py

@@ -0,0 +1,5 @@
+# QuantumFlow API routes
+from quantumflow.api.routes.billing_routes import router as billing_router
+from quantumflow.api.routes.workflow_routes import router as workflow_router
+
+__all__ = ["billing_router", "workflow_router"]

quantumflow_sdk-0.2.1/src/quantumflow/api/routes/workflow_routes.py

@@ -0,0 +1,227 @@
+"""
+Workflow API Routes.
+
+Provides REST API endpoints for quantum workflow orchestration.
+"""
+
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class WorkflowStepRequest:
+    """Request model for a workflow step."""
+    type: str
+    params: Optional[Dict[str, Any]] = None
+    depends_on: Optional[List[str]] = None
+    id: Optional[str] = None
+
+
+@dataclass
+class WorkflowRequest:
+    """Request model for creating a workflow."""
+    steps: List[Dict[str, Any]]
+    backend: str = "simulator"
+
+
+@dataclass
+class WorkflowResponse:
+    """Response model for workflow execution."""
+    workflow_id: str
+    status: str
+    steps: List[Dict[str, Any]]
+    total_duration_ms: float
+    outputs: Dict[str, Any]
+    error: Optional[str] = None
+
+
+def create_workflow_routes():
+    """
+    Create workflow API routes.
+
+    Returns a router that can be mounted on a FastAPI app.
+
+    Example usage with FastAPI:
+        from fastapi import FastAPI
+        from quantumflow.api.routes.workflow_routes import create_workflow_routes
+
+        app = FastAPI()
+        workflow_router = create_workflow_routes()
+        app.include_router(workflow_router, prefix="/v1/workflow")
+    """
+    try:
+        from fastapi import APIRouter, HTTPException
+        from pydantic import BaseModel
+    except ImportError:
+        # Return a dummy router if FastAPI is not installed
+        return None
+
+    router = APIRouter(tags=["workflow"])
+
+    class WorkflowStepModel(BaseModel):
+        type: str
+        params: Optional[Dict[str, Any]] = None
+        depends_on: Optional[List[str]] = None
+        id: Optional[str] = None
+
+    class CreateWorkflowModel(BaseModel):
+        steps: List[WorkflowStepModel]
+        backend: str = "simulator"
+
+    class ExecuteWorkflowModel(BaseModel):
+        workflow_id: Optional[str] = None
+        steps: Optional[List[WorkflowStepModel]] = None
+        backend: str = "simulator"
+
+    @router.post("/create")
+    async def create_workflow(request: CreateWorkflowModel) -> Dict[str, Any]:
+        """
+        Create a new workflow without executing it.
+
+        Returns the workflow definition that can be executed later.
+        """
+        from quantumflow.core.workflow import QuantumWorkflow
+
+        workflow = QuantumWorkflow(backend=request.backend)
+
+        for step in request.steps:
+            workflow.add_step(
+                step_type=step.type,
+                params=step.params,
+                depends_on=step.depends_on,
+                step_id=step.id,
+            )
+
+        return workflow.to_dict()
+
+    @router.post("/execute")
+    async def execute_workflow(request: ExecuteWorkflowModel) -> Dict[str, Any]:
+        """
+        Execute a quantum workflow.
+
+        Can either:
+        - Execute a new workflow by providing steps
+        - Execute an existing workflow by providing workflow_id
+
+        Returns execution results for all steps.
+        """
+        from quantumflow.core.workflow import QuantumWorkflow
+
+        if not request.steps:
+            raise HTTPException(
+                status_code=400,
+                detail="Steps are required to execute a workflow"
+            )
+
+        workflow = QuantumWorkflow(backend=request.backend)
+
+        for step in request.steps:
+            workflow.add_step(
+                step_type=step.type,
+                params=step.params,
+                depends_on=step.depends_on,
+                step_id=step.id,
+            )
+
+        result = workflow.execute()
+
+        return {
+            "workflow_id": result.workflow_id,
+            "status": result.status,
+            "steps": result.steps,
+            "total_duration_ms": result.total_duration_ms,
+            "outputs": result.outputs,
+            "error": result.error,
+        }
+
+    @router.post("/compress-and-teleport")
+    async def compress_and_teleport(
+        tokens: List[int],
+        recipient: Optional[str] = None,
+        backend: str = "simulator",
+    ) -> Dict[str, Any]:
+        """
+        Convenience endpoint that combines compression and teleportation.
+
+        This is a common workflow pattern for secure quantum messaging.
+        """
+        from quantumflow.core.workflow import QuantumWorkflow
+
+        workflow = QuantumWorkflow(backend=backend)
+
+        # Step 1: Compress tokens
+        workflow.add_step(
+            step_type="compress",
+            params={"tokens": tokens},
+            step_id="compression",
+        )
+
+        # Step 2: QKD key exchange
+        workflow.add_step(
+            step_type="qkd",
+            params={"key_length": 256},
+            step_id="key_exchange",
+            depends_on=["compression"],
+        )
+
+        # Step 3: Create Bell pairs for teleportation
+        workflow.add_step(
+            step_type="teleport",
+            params={"n_pairs": 10},
+            step_id="teleportation",
+            depends_on=["key_exchange"],
+        )
+
+        result = workflow.execute()
+
+        return {
+            "workflow_id": result.workflow_id,
+            "status": result.status,
+            "compression": result.outputs.get("compression", {}),
+            "qkd": result.outputs.get("key_exchange", {}),
+            "teleportation": result.outputs.get("teleportation", {}),
+            "total_duration_ms": result.total_duration_ms,
+        }
+
+    @router.get("/templates")
+    async def get_workflow_templates() -> List[Dict[str, Any]]:
+        """
+        Get available workflow templates.
+
+        Returns predefined workflow configurations for common use cases.
+        """
+        return [
+            {
+                "name": "secure_messaging",
+                "description": "Compress tokens, exchange QKD key, and teleport",
+                "steps": [
+                    {"type": "compress", "params": {"tokens": []}, "id": "compress"},
+                    {"type": "qkd", "params": {"key_length": 256}, "id": "qkd", "depends_on": ["compress"]},
+                    {"type": "teleport", "params": {"n_pairs": 10}, "id": "teleport", "depends_on": ["qkd"]},
+                ],
+            },
+            {
+                "name": "quantum_ml_training",
+                "description": "Quantum backpropagation workflow",
+                "steps": [
+                    {"type": "compress", "params": {"tokens": []}, "id": "compress_input"},
+                    {"type": "backprop", "params": {}, "id": "gradient", "depends_on": ["compress_input"]},
+                ],
+            },
+            {
+                "name": "optimization",
+                "description": "QAOA optimization workflow",
+                "steps": [
+                    {"type": "qaoa", "params": {"p": 2}, "id": "optimize"},
+                ],
+            },
+        ]
+
+    return router
+
+
+# Export router for use with FastAPI
+try:
+    router = create_workflow_routes()
+except Exception:
+    router = None

quantumflow_sdk-0.2.1/src/quantumflow/core/workflow.py

@@ -0,0 +1,311 @@
+"""
+Quantum Workflow Orchestration Module.
+
+Provides workflow orchestration for chaining quantum operations like:
+- Token compression
+- QKD key exchange
+- Quantum teleportation
+- Algorithm execution
+
+Example:
+    from quantumflow.core.workflow import QuantumWorkflow
+
+    workflow = QuantumWorkflow()
+    workflow.add_step("compress", tokens=[100, 200, 150])
+    workflow.add_step("qkd", key_length=256)
+    workflow.add_step("teleport", use_compression=True)
+    result = workflow.execute()
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+from enum import Enum
+import time
+import uuid
+
+
+class StepType(Enum):
+    """Types of workflow steps."""
+    COMPRESS = "compress"
+    DECOMPRESS = "decompress"
+    QKD = "qkd"
+    TELEPORT = "teleport"
+    BACKPROP = "backprop"
+    QAOA = "qaoa"
+    VQE = "vqe"
+    CUSTOM = "custom"
+
+
+class StepStatus(Enum):
+    """Status of a workflow step."""
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+
+
+@dataclass
+class WorkflowStep:
+    """A single step in a quantum workflow."""
+    id: str
+    step_type: StepType
+    params: Dict[str, Any]
+    status: StepStatus = StepStatus.PENDING
+    result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    started_at: Optional[float] = None
+    completed_at: Optional[float] = None
+    depends_on: List[str] = field(default_factory=list)
+
+    @property
+    def duration_ms(self) -> Optional[float]:
+        """Duration of step execution in milliseconds."""
+        if self.started_at and self.completed_at:
+            return (self.completed_at - self.started_at) * 1000
+        return None
+
+
+@dataclass
+class WorkflowResult:
+    """Result of workflow execution."""
+    workflow_id: str
+    status: str
+    steps: List[Dict[str, Any]]
+    total_duration_ms: float
+    outputs: Dict[str, Any]
+    error: Optional[str] = None
+
+
+class QuantumWorkflow:
+    """
+    Orchestrates quantum operations in a workflow.
+
+    Supports:
+    - Sequential step execution
+    - Dependency management between steps
+    - Error handling and recovery
+    - Step result passing to subsequent steps
+    """
+
+    def __init__(self, backend: str = "simulator"):
+        """
+        Initialize a quantum workflow.
+
+        Args:
+            backend: Quantum backend to use (simulator, ibm, braket)
+        """
+        self.workflow_id = str(uuid.uuid4())
+        self.backend = backend
+        self.steps: List[WorkflowStep] = []
+        self._step_results: Dict[str, Any] = {}
+
+    def add_step(
+        self,
+        step_type: str,
+        params: Optional[Dict[str, Any]] = None,
+        depends_on: Optional[List[str]] = None,
+        step_id: Optional[str] = None,
+    ) -> str:
+        """
+        Add a step to the workflow.
+
+        Args:
+            step_type: Type of step (compress, qkd, teleport, etc.)
+            params: Parameters for the step
+            depends_on: List of step IDs this step depends on
+            step_id: Optional custom step ID
+
+        Returns:
+            The ID of the created step
+        """
+        if step_id is None:
+            step_id = f"step_{len(self.steps) + 1}"
+
+        step = WorkflowStep(
+            id=step_id,
+            step_type=StepType(step_type),
+            params=params or {},
+            depends_on=depends_on or [],
+        )
+        self.steps.append(step)
+        return step_id
+
+    def _execute_step(self, step: WorkflowStep) -> Dict[str, Any]:
+        """
+        Execute a single workflow step.
+
+        Args:
+            step: The step to execute
+
+        Returns:
+            Result of the step execution
+        """
+        from quantumflow.core.quantum_compressor import QuantumCompressor
+        from quantumflow.core.teleportation import QKDExchange, QuantumTeleporter
+
+        step.status = StepStatus.RUNNING
+        step.started_at = time.time()
+
+        try:
+            result = {}
+
+            if step.step_type == StepType.COMPRESS:
+                compressor = QuantumCompressor(backend=self.backend)
+                tokens = step.params.get("tokens", [])
+                compressed = compressor.compress(tokens)
+                result = {
+                    "amplitudes": compressed.amplitudes.tolist() if hasattr(compressed.amplitudes, 'tolist') else compressed.amplitudes,
+                    "n_qubits": compressed.n_qubits,
+                    "compression_percentage": compressed.compression_percentage,
+                    "input_token_count": compressed.input_token_count,
+                }
+
+            elif step.step_type == StepType.QKD:
+                qkd = QKDExchange(backend=self.backend)
+                key_length = step.params.get("key_length", 256)
+                qkd_result = qkd.exchange(key_length=key_length)
+                result = qkd_result
+
+            elif step.step_type == StepType.TELEPORT:
+                teleporter = QuantumTeleporter(backend=self.backend)
+                state = step.params.get("state")
+                if state:
+                    teleport_result = teleporter.teleport_state(state)
+                    result = {
+                        "fidelity": teleport_result.fidelity,
+                        "corrections_applied": teleport_result.corrections_applied,
+                    }
+                else:
+                    # Create Bell pairs
+                    n_pairs = step.params.get("n_pairs", 10)
+                    pairs = teleporter.create_bell_pairs(n_pairs)
+                    result = {"bell_pairs_created": n_pairs}
+
+            elif step.step_type == StepType.BACKPROP:
+                from quantumflow.core.quantum_backprop import QuantumBackprop
+                backprop = QuantumBackprop(backend=self.backend)
+                bp_result = backprop.compute_gradient(
+                    input_state=step.params.get("input_state", [0.5, 0.5]),
+                    target_state=step.params.get("target_state", [0.8, 0.2]),
+                    weights=step.params.get("weights", [0.3, 0.7]),
+                )
+                result = {
+                    "gradients": bp_result.gradients,
+                    "similarity": bp_result.similarity,
+                }
+
+            elif step.step_type == StepType.QAOA:
+                from quantumflow.algorithms.optimization.qaoa import QuantumQAOA
+                qaoa = QuantumQAOA(backend=self.backend)
+                qaoa_result = qaoa.optimize(
+                    problem=step.params.get("problem", {}),
+                    p=step.params.get("p", 2),
+                )
+                result = qaoa_result
+
+            elif step.step_type == StepType.VQE:
+                from quantumflow.algorithms.machine_learning.vqe import QuantumVQE
+                vqe = QuantumVQE(backend=self.backend)
+                vqe_result = vqe.find_ground_state(
+                    hamiltonian=step.params.get("hamiltonian", {}),
+                )
+                result = vqe_result
+
+            else:
+                # Custom step - just pass through params
+                result = step.params
+
+            step.status = StepStatus.COMPLETED
+            step.result = result
+            step.completed_at = time.time()
+
+            return result
+
+        except Exception as e:
+            step.status = StepStatus.FAILED
+            step.error = str(e)
+            step.completed_at = time.time()
+            raise
+
+    def execute(self) -> WorkflowResult:
+        """
+        Execute all steps in the workflow.
+
+        Returns:
+            WorkflowResult with all step results
+        """
+        start_time = time.time()
+        outputs = {}
+        error = None
+
+        try:
+            for step in self.steps:
+                # Check dependencies
+                for dep_id in step.depends_on:
+                    dep_step = next((s for s in self.steps if s.id == dep_id), None)
+                    if dep_step and dep_step.status != StepStatus.COMPLETED:
+                        step.status = StepStatus.SKIPPED
+                        step.error = f"Dependency {dep_id} not completed"
+                        continue
+
+                # Execute the step
+                result = self._execute_step(step)
+                self._step_results[step.id] = result
+                outputs[step.id] = result
+
+        except Exception as e:
+            error = str(e)
+
+        end_time = time.time()
+
+        return WorkflowResult(
+            workflow_id=self.workflow_id,
+            status="completed" if error is None else "failed",
+            steps=[
+                {
+                    "id": s.id,
+                    "type": s.step_type.value,
+                    "status": s.status.value,
+                    "result": s.result,
+                    "error": s.error,
+                    "duration_ms": s.duration_ms,
+                }
+                for s in self.steps
+            ],
+            total_duration_ms=(end_time - start_time) * 1000,
+            outputs=outputs,
+            error=error,
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert workflow to dictionary representation."""
+        return {
+            "workflow_id": self.workflow_id,
+            "backend": self.backend,
+            "steps": [
+                {
+                    "id": s.id,
+                    "type": s.step_type.value,
+                    "params": s.params,
+                    "depends_on": s.depends_on,
+                }
+                for s in self.steps
+            ],
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "QuantumWorkflow":
+        """Create workflow from dictionary representation."""
+        workflow = cls(backend=data.get("backend", "simulator"))
+        workflow.workflow_id = data.get("workflow_id", workflow.workflow_id)
+
+        for step_data in data.get("steps", []):
+            workflow.add_step(
+                step_type=step_data["type"],
+                params=step_data.get("params", {}),
+                depends_on=step_data.get("depends_on", []),
+                step_id=step_data.get("id"),
+            )
+
+        return workflow

{quantumflow_sdk-0.1.0 → quantumflow_sdk-0.2.1}/src/quantumflow/integrations/__init__.py

@@ -2,12 +2,21 @@
 QuantumFlow Integrations.
 
 Provides integration with popular AI agent frameworks:
+- OpenAI: Function calling for GPT-4/GPT-3.5-turbo
 - LangChain: Tools, Memory, and Chains
 - CrewAI: Tools and Agents
 - AutoGen: Agents and Function Tools
 - MCP: Model Context Protocol Server
 """
 
+# OpenAI Integration
+from quantumflow.integrations.openai_functions import (
+    get_quantum_functions as get_openai_functions,
+    get_quantum_tools as get_openai_tools,
+    execute_quantum_function,
+    QuantumAssistant,
+)
+
 # LangChain Integration
 from quantumflow.integrations.langchain_tools import (
     QuantumCompressTool,
@@ -64,6 +73,11 @@ from quantumflow.integrations.mcp_server import (
 )
 
 __all__ = [
+    # OpenAI Functions
+    "get_openai_functions",
+    "get_openai_tools",
+    "execute_quantum_function",
+    "QuantumAssistant",
     # LangChain Tools
     "QuantumCompressTool",
     "QuantumGradientTool",