quantumflow-sdk 0.1.0__py3-none-any.whl

quantumflow/backends/simulator_backend.py

@@ -0,0 +1,86 @@
+"""
+Simulator Backend - Local quantum simulator using Qiskit Aer.
+"""
+
+import time
+from typing import Optional
+import numpy as np
+from qiskit import QuantumCircuit, transpile
+from qiskit_aer import AerSimulator
+from qiskit.quantum_info import Statevector
+
+from quantumflow.backends.base_backend import (
+    QuantumBackend,
+    BackendType,
+    ExecutionResult,
+)
+
+
+class SimulatorBackend(QuantumBackend):
+    """Local quantum simulator using Qiskit Aer."""
+
+    def __init__(self, method: str = "statevector", noise_model: Optional[object] = None):
+        super().__init__(BackendType.SIMULATOR)
+        self.method = method
+        self.noise_model = noise_model
+        self._simulator: Optional[AerSimulator] = None
+        self._max_qubits = 30
+
+    def connect(self) -> bool:
+        try:
+            self._simulator = AerSimulator(method=self.method)
+            if self.noise_model:
+                self._simulator.set_options(noise_model=self.noise_model)
+            self._is_connected = True
+            return True
+        except Exception as e:
+            raise ConnectionError(f"Failed to initialize simulator: {e}")
+
+    def disconnect(self) -> None:
+        self._simulator = None
+        self._is_connected = False
+
+    def execute(
+        self,
+        circuit: QuantumCircuit,
+        shots: int = 1024,
+        optimization_level: int = 1,
+    ) -> ExecutionResult:
+        if not self._is_connected:
+            self.connect()
+
+        self.validate_circuit(circuit)
+        start_time = time.perf_counter()
+
+        # Get statevector if no measurements
+        has_measurements = any(inst.operation.name == "measure" for inst in circuit.data)
+        statevector = None if has_measurements else self.get_statevector(circuit)
+
+        # Add measurements for sampling
+        exec_circuit = circuit.copy()
+        if not has_measurements:
+            exec_circuit.measure_all()
+
+        transpiled = transpile(exec_circuit, self._simulator, optimization_level=optimization_level)
+        job = self._simulator.run(transpiled, shots=shots)
+        counts = job.result().get_counts()
+
+        return ExecutionResult(
+            counts=counts,
+            statevector=statevector,
+            shots=shots,
+            backend_name="aer_simulator",
+            execution_time_ms=(time.perf_counter() - start_time) * 1000,
+            fidelity=1.0,
+        )
+
+    def get_statevector(self, circuit: QuantumCircuit) -> np.ndarray:
+        return Statevector(circuit).data
+
+    @property
+    def max_qubits(self) -> int:
+        return self._max_qubits
+
+    @property
+    def is_simulator(self) -> bool:
+        return True

quantumflow/billing/__init__.py

@@ -0,0 +1,25 @@
+"""QuantumFlow Billing - Stripe integration for subscriptions and usage billing."""
+
+from quantumflow.billing.stripe_service import (
+    StripeService,
+    SubscriptionTier,
+    TIER_PRICES,
+    TIER_LIMITS,
+)
+from quantumflow.billing.models import (
+    Customer,
+    Subscription,
+    Invoice,
+    UsageRecord,
+)
+
+__all__ = [
+    "StripeService",
+    "SubscriptionTier",
+    "TIER_PRICES",
+    "TIER_LIMITS",
+    "Customer",
+    "Subscription",
+    "Invoice",
+    "UsageRecord",
+]

quantumflow/billing/models.py

@@ -0,0 +1,126 @@
+"""Billing data models for Stripe integration."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+
+class SubscriptionStatus(str, Enum):
+    """Stripe subscription statuses."""
+    ACTIVE = "active"
+    PAST_DUE = "past_due"
+    CANCELED = "canceled"
+    UNPAID = "unpaid"
+    TRIALING = "trialing"
+    INCOMPLETE = "incomplete"
+    INCOMPLETE_EXPIRED = "incomplete_expired"
+    PAUSED = "paused"
+
+
+class PaymentStatus(str, Enum):
+    """Payment/Invoice statuses."""
+    DRAFT = "draft"
+    OPEN = "open"
+    PAID = "paid"
+    VOID = "void"
+    UNCOLLECTIBLE = "uncollectible"
+
+
+@dataclass
+class Customer:
+    """Stripe customer representation."""
+    id: str
+    email: str
+    name: Optional[str] = None
+    stripe_customer_id: Optional[str] = None
+    default_payment_method: Optional[str] = None
+    created_at: datetime = field(default_factory=datetime.utcnow)
+    metadata: dict = field(default_factory=dict)
+
+    @property
+    def has_payment_method(self) -> bool:
+        return self.default_payment_method is not None
+
+
+@dataclass
+class Subscription:
+    """Stripe subscription representation."""
+    id: str
+    customer_id: str
+    stripe_subscription_id: str
+    tier: str
+    status: SubscriptionStatus
+    current_period_start: datetime
+    current_period_end: datetime
+    cancel_at_period_end: bool = False
+    canceled_at: Optional[datetime] = None
+    trial_end: Optional[datetime] = None
+    created_at: datetime = field(default_factory=datetime.utcnow)
+    metadata: dict = field(default_factory=dict)
+
+    @property
+    def is_active(self) -> bool:
+        return self.status in {SubscriptionStatus.ACTIVE, SubscriptionStatus.TRIALING}
+
+    @property
+    def days_remaining(self) -> int:
+        if self.current_period_end:
+            delta = self.current_period_end - datetime.utcnow()
+            return max(0, delta.days)
+        return 0
+
+
+@dataclass
+class Invoice:
+    """Stripe invoice representation."""
+    id: str
+    customer_id: str
+    stripe_invoice_id: str
+    subscription_id: Optional[str]
+    amount_due: int  # in cents
+    amount_paid: int
+    currency: str
+    status: PaymentStatus
+    invoice_pdf: Optional[str] = None
+    hosted_invoice_url: Optional[str] = None
+    period_start: Optional[datetime] = None
+    period_end: Optional[datetime] = None
+    created_at: datetime = field(default_factory=datetime.utcnow)
+
+    @property
+    def amount_due_dollars(self) -> float:
+        return self.amount_due / 100
+
+    @property
+    def amount_paid_dollars(self) -> float:
+        return self.amount_paid / 100
+
+
+@dataclass
+class UsageRecord:
+    """Usage record for metered billing."""
+    id: str
+    subscription_id: str
+    quantity: int  # API calls
+    timestamp: datetime
+    action: str = "increment"  # or "set"
+    idempotency_key: Optional[str] = None
+    metadata: dict = field(default_factory=dict)
+
+
+@dataclass
+class PriceInfo:
+    """Pricing information for a tier."""
+    tier: str
+    stripe_price_id: str
+    amount: int  # monthly price in cents
+    stripe_product_id: str = ""
+    currency: str = "usd"
+    interval: str = "month"
+    api_calls_included: int = 0
+    overage_price_per_call: float = 0.0  # in cents
+
+    @property
+    def monthly_price_dollars(self) -> float:
+        return self.amount / 100