subscription-sdk 1.0.0__py3-none-any.whl

subscription_sdk/__init__.py

@@ -0,0 +1,24 @@
+from .types import Mapping, SdkConfig, EntitlementCheckResponse
+from .config_manager import ConfigManager
+from .poller import Poller
+from .route_matcher import RouteMatcher
+from .client import SubscriptionClient
+
+# Export flask and fastapi adapters dynamically to avoid hard dependencies if users don't have those libraries installed
+def get_flask_adapter():
+    from .adapters.flask_adapter import subscription_flask
+    return subscription_flask
+
+def get_fastapi_middleware():
+    from .adapters.fastapi_adapter import SubscriptionMiddleware
+    return SubscriptionMiddleware
+
+__all__ = [
+    'Mapping',
+    'SdkConfig',
+    'EntitlementCheckResponse',
+    'ConfigManager',
+    'Poller',
+    'RouteMatcher',
+    'SubscriptionClient',
+]

subscription_sdk/adapters/fastapi_adapter.py

@@ -0,0 +1,105 @@
+import inspect
+import os
+from typing import Callable, Optional, Union, Awaitable
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response, JSONResponse
+from ..client import SubscriptionClient
+
+class SubscriptionMiddleware(BaseHTTPMiddleware):
+    def __init__(
+        self,
+        app,
+        client: Optional[SubscriptionClient] = None,
+        get_org_id: Optional[Union[Callable[[Request], str], Callable[[Request], Awaitable[str]]]] = None,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None
+    ):
+        super().__init__(app)
+        if not get_org_id:
+            raise ValueError("get_org_id callback is required")
+        
+        self.get_org_id = get_org_id
+        
+        if client is None:
+            key = api_key or os.environ.get("SUBSCRIPTION_API_KEY")
+            url = base_url or os.environ.get("SUBSCRIPTION_BASE_URL")
+            if not key or not url:
+                raise ValueError("Subscription API Key and Base URL are required when client is not provided")
+            self.client = SubscriptionClient(key, url)
+            self.client.start()
+        else:
+            self.client = client
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        path = request.url.path
+        method = request.method
+        
+        mapping = self.client.match_route(method, path)
+        if not mapping:
+            return await call_next(request)
+
+        # Resolve org identifier
+        if inspect.iscoroutinefunction(self.get_org_id):
+            org_id = await self.get_org_id(request)
+        else:
+            org_id = self.get_org_id(request)
+
+        if not org_id:
+            return JSONResponse(
+                status_code=400,
+                content={
+                    "title": "Organization Identity Missing",
+                    "status": 400,
+                    "detail": "No organization external identifier resolved for the matching route."
+                }
+            )
+
+        try:
+            check_result = self.client.check_entitlement(org_id, mapping.id, 1.0)
+        except Exception as e:
+            return JSONResponse(
+                status_code=500,
+                content={
+                    "title": "Entitlement Resolution Error",
+                    "status": 500,
+                    "detail": str(e)
+                }
+            )
+
+        if not check_result.allowed:
+            detail = check_result.detail or f"Subscription limit reached or feature not enabled: {check_result.featureCode}"
+            code = check_result.code or "ENTITLEMENT_DENIED"
+            return JSONResponse(
+                status_code=403,
+                content={
+                    "title": "Entitlement Denied",
+                    "status": 403,
+                    "detail": detail,
+                    "code": code
+                }
+            )
+
+        # Attach reservation context to request state
+        request.state.subscription_reservation_id = check_result.reservationId
+
+        success = False
+        try:
+            response = await call_next(request)
+            if response.status_code < 400:
+                success = True
+            return response
+        finally:
+            reservation_id = getattr(request.state, 'subscription_reservation_id', None)
+            if reservation_id:
+                try:
+                    if success:
+                        self.client.commit_reservation(reservation_id)
+                    else:
+                        self.client.cancel_reservation(reservation_id)
+                except Exception as e:
+                    import sys
+                    print(
+                        f"[SubscriptionSDK] Failed to {'commit' if success else 'cancel'} reservation {reservation_id}: {e}",
+                        file=sys.stderr
+                    )

subscription_sdk/adapters/flask_adapter.py

@@ -0,0 +1,84 @@
+import os
+from typing import Callable, Optional
+from flask import request, jsonify, g
+from ..client import SubscriptionClient
+
+def subscription_flask(
+    app,
+    client: Optional[SubscriptionClient] = None,
+    get_org_id: Optional[Callable[[], Optional[str]]] = None,
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None
+) -> SubscriptionClient:
+    
+    if not get_org_id:
+        raise ValueError("get_org_id callback is required")
+        
+    if client is None:
+        key = api_key or os.environ.get("SUBSCRIPTION_API_KEY")
+        url = base_url or os.environ.get("SUBSCRIPTION_BASE_URL")
+        if not key or not url:
+            raise ValueError("Subscription API Key and Base URL are required when client is not provided")
+        client = SubscriptionClient(key, url)
+        client.start()
+
+    @app.before_request
+    def before_req():
+        path = request.path
+        method = request.method
+        
+        mapping = client.match_route(method, path)
+        if not mapping:
+            return None  # Bypass
+            
+        org_id = get_org_id()
+        if not org_id:
+            return jsonify({
+                "title": "Organization Identity Missing",
+                "status": 400,
+                "detail": "No organization external identifier resolved for the matching route."
+            }), 400
+            
+        try:
+            check_result = client.check_entitlement(org_id, mapping.id, 1.0)
+        except Exception as e:
+            return jsonify({
+                "title": "Entitlement Resolution Error",
+                "status": 500,
+                "detail": str(e)
+            }), 500
+
+        if not check_result.allowed:
+            detail = check_result.detail or f"Subscription limit reached or feature not enabled: {check_result.featureCode}"
+            code = check_result.code or "ENTITLEMENT_DENIED"
+            return jsonify({
+                "title": "Entitlement Denied",
+                "status": 403,
+                "detail": detail,
+                "code": code
+            }), 403
+
+        # Attach reservation context to request state
+        g.subscription_reservation_id = check_result.reservationId
+        request.subscription_reservation_id = check_result.reservationId
+        return None
+
+    @app.after_request
+    def after_req(response):
+        reservation_id = getattr(g, 'subscription_reservation_id', None)
+        if reservation_id:
+            success = response.status_code < 400
+            try:
+                if success:
+                    client.commit_reservation(reservation_id)
+                else:
+                    client.cancel_reservation(reservation_id)
+            except Exception as e:
+                import sys
+                print(
+                    f"[SubscriptionSDK] Failed to {'commit' if success else 'cancel'} reservation {reservation_id}: {e}",
+                    file=sys.stderr
+                )
+        return response
+
+    return client

subscription_sdk/client.py

@@ -0,0 +1,198 @@
+import json
+import platform
+import socket
+import urllib.request
+import urllib.error
+from typing import Optional, Callable, Any
+from .types import SdkConfig, EntitlementCheckResponse, Mapping
+from .config_manager import ConfigManager
+from .poller import Poller
+from .route_matcher import RouteMatcher
+
+class SubscriptionClient:
+    def __init__(self, api_key: str, base_url: str, poll_interval_sec: float = 60.0, poll_jitter: float = 0.30):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip('/')
+        self.config_manager = ConfigManager()
+        self.poller = Poller(self.sync_config, poll_interval_sec, poll_jitter)
+        self.current_etag: Optional[str] = None
+        self.current_revision: int = 0
+
+    def start(self) -> None:
+        # Initial fetch must succeed or fail during startup.
+        # If it fails on first startup, it raises an exception.
+        self.sync_config()
+        self.poller.start()
+
+    def stop(self) -> None:
+        self.poller.stop()
+
+    def get_config(self) -> Optional[SdkConfig]:
+        return self.config_manager.get_config()
+
+    def sync_config(self) -> None:
+        url = f"{self.base_url}/sdk/v1/config"
+        
+        hostname = "unknown-python-host"
+        try:
+            hostname = socket.gethostname()
+        except Exception:
+            pass
+
+        headers = {
+            'Authorization': f"Bearer {self.api_key}",
+            'Accept': 'application/json',
+            'X-SDK-Language': 'Python',
+            'X-SDK-Version': '1.0.0',
+            'X-SDK-Runtime': f"Python {platform.python_version()}",
+            'X-SDK-Hostname': hostname
+        }
+
+        if self.current_etag:
+            headers['If-None-Match'] = self.current_etag
+
+        req = urllib.request.Request(url, headers=headers, method='GET')
+        
+        try:
+            with urllib.request.urlopen(req, timeout=10) as response:
+                status = response.status
+                
+                if status == 304:
+                    return
+
+                if status != 200:
+                    raise RuntimeError(f"Sync config failed with status {status}")
+
+                body_bytes = response.read()
+                body_json = json.loads(body_bytes.decode('utf-8'))
+
+                # Extract headers (case-insensitive key check)
+                resp_headers = response.info()
+                etag = resp_headers.get('ETag')
+                if etag:
+                    self.current_etag = etag
+                
+                rev_header = resp_headers.get('X-Config-Revision')
+                if rev_header:
+                    try:
+                        self.current_revision = int(rev_header)
+                    except ValueError:
+                        pass
+
+                config = SdkConfig.from_dict(body_json)
+                self.config_manager.update_config(config)
+
+        except urllib.error.HTTPError as e:
+            if e.code == 304:
+                return  # Unchanged
+            raise RuntimeError(f"Sync config failed with status {e.code}: {e.read().decode('utf-8', errors='ignore')}") from e
+        except Exception as e:
+            raise RuntimeError(f"Sync config encountered an error: {e}") from e
+
+    def match_route(self, method: str, path: str) -> Optional[Mapping]:
+        config = self.config_manager.get_config()
+        if not config or not config.mappings:
+            return None
+        return RouteMatcher.match(method, path, config.mappings)
+
+    def check_entitlement(
+        self,
+        organization_external_id: str,
+        resource_mapping_id: str,
+        quantity: float,
+        idempotency_key: Optional[str] = None
+    ) -> EntitlementCheckResponse:
+        url = f"{self.base_url}/sdk/v1/entitlements/check"
+        
+        body = {
+            'organizationExternalId': organization_external_id,
+            'resourceMappingId': resource_mapping_id,
+            'quantity': quantity
+        }
+        if idempotency_key:
+            body['idempotencyKey'] = idempotency_key
+
+        data = json.dumps(body).encode('utf-8')
+        headers = {
+            'Authorization': f"Bearer {self.api_key}",
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        }
+
+        req = urllib.request.Request(url, data=data, headers=headers, method='POST')
+
+        try:
+            with urllib.request.urlopen(req, timeout=10) as response:
+                if response.status != 200:
+                    raise RuntimeError(f"Entitlement check failed: status {response.status}")
+                body_bytes = response.read()
+                body_json = json.loads(body_bytes.decode('utf-8'))
+                return EntitlementCheckResponse.from_dict(body_json)
+        except urllib.error.HTTPError as e:
+            err_text = e.read().decode('utf-8', errors='ignore')
+            raise RuntimeError(f"Entitlement check failed with status {e.code}: {err_text}") from e
+        except Exception as e:
+            raise RuntimeError(f"Entitlement check encountered an error: {e}") from e
+
+    def commit_reservation(self, reservation_id: str) -> None:
+        url = f"{self.base_url}/sdk/v1/reservations/{reservation_id}/commit"
+        headers = {
+            'Authorization': f"Bearer {self.api_key}"
+        }
+        req = urllib.request.Request(url, headers=headers, method='POST')
+        
+        try:
+            with urllib.request.urlopen(req, timeout=10) as response:
+                if response.status not in (200, 204, 244):
+                    raise RuntimeError(f"Commit reservation failed: status {response.status}")
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(f"Commit reservation failed with status {e.code}") from e
+        except Exception as e:
+            raise RuntimeError(f"Commit reservation encountered an error: {e}") from e
+
+    def cancel_reservation(self, reservation_id: str) -> None:
+        url = f"{self.base_url}/sdk/v1/reservations/{reservation_id}/cancel"
+        headers = {
+            'Authorization': f"Bearer {self.api_key}"
+        }
+        req = urllib.request.Request(url, headers=headers, method='POST')
+        
+        try:
+            with urllib.request.urlopen(req, timeout=10) as response:
+                if response.status not in (200, 204, 244):
+                    raise RuntimeError(f"Cancel reservation failed: status {response.status}")
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(f"Cancel reservation failed with status {e.code}") from e
+        except Exception as e:
+            raise RuntimeError(f"Cancel reservation encountered an error: {e}") from e
+
+    def execute(
+        self,
+        organization_id: str,
+        resource_mapping_id: str,
+        callback: Callable[[], Any],
+        quantity: float = 1.0,
+        idempotency_key: Optional[str] = None
+    ) -> Any:
+        check = self.check_entitlement(
+            organization_external_id=organization_id,
+            resource_mapping_id=resource_mapping_id,
+            quantity=quantity,
+            idempotency_key=idempotency_key
+        )
+        if not check.allowed:
+            raise PermissionError(check.detail or f"Entitlement check denied for feature: {check.featureCode}")
+
+        reservation_id = check.reservationId
+        try:
+            result = callback()
+            if reservation_id:
+                self.commit_reservation(reservation_id)
+            return result
+        except Exception as e:
+            if reservation_id:
+                try:
+                    self.cancel_reservation(reservation_id)
+                except Exception:
+                    pass
+            raise e

subscription_sdk/config_manager.py

@@ -0,0 +1,16 @@
+import threading
+from typing import Optional
+from .types import SdkConfig
+
+class ConfigManager:
+    def __init__(self):
+        self._current_config: Optional[SdkConfig] = None
+        self._lock = threading.RLock()
+
+    def get_config(self) -> Optional[SdkConfig]:
+        with self._lock:
+            return self._current_config
+
+    def update_config(self, new_config: SdkConfig) -> None:
+        with self._lock:
+            self._current_config = new_config

subscription_sdk/poller.py

@@ -0,0 +1,74 @@
+import random
+import threading
+import time
+from typing import Callable, Optional
+
+class Poller:
+    def __init__(self, sync_fn: Callable[[], None], poll_interval_sec: float = 60.0, poll_jitter: float = 0.30):
+        self._sync_fn = sync_fn
+        self._base_interval_sec = poll_interval_sec
+        self._jitter_percent = poll_jitter
+        self._is_running = False
+        self._consecutive_failures = 0
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+        self._lock = threading.Lock()
+
+    def start(self) -> None:
+        with self._lock:
+            if self._is_running:
+                return
+            self._is_running = True
+            self._consecutive_failures = 0
+            self._stop_event.clear()
+            self._thread = threading.Thread(target=self._run, daemon=True)
+            self._thread.start()
+
+    def stop(self) -> None:
+        with self._lock:
+            if not self._is_running:
+                return
+            self._is_running = False
+            self._stop_event.set()
+            # We don't join blockingly for a long time to keep stop() fast
+            self._thread = None
+
+    def _run(self) -> None:
+        # Randomized initial delay: 0 to 5 seconds to prevent thundering herd
+        initial_delay = random.uniform(0.0, 5.0)
+        if self._stop_event.wait(initial_delay):
+            return
+
+        while self._is_running and not self._stop_event.is_set():
+            try:
+                self._sync_fn()
+                self._consecutive_failures = 0
+            except Exception as e:
+                self._consecutive_failures += 1
+                # Log error
+                import sys
+                print(
+                    f"[SubscriptionSDK] Config poll failed (consecutive: {self._consecutive_failures}): {e}",
+                    file=sys.stderr
+                )
+
+            if not self._is_running or self._stop_event.is_set():
+                break
+
+            delay = self._calculate_next_delay()
+            if self._stop_event.wait(delay):
+                break
+
+    def _calculate_next_delay(self) -> float:
+        if self._consecutive_failures > 0:
+            # Exponential backoff with full jitter: min(max_backoff, base * 2 ^ failures)
+            base_backoff = 2.0  # 2 seconds
+            max_backoff = 60.0  # 60 seconds
+            exp_val = min(max_backoff, base_backoff * (2.0 ** self._consecutive_failures))
+            # Full jitter: random between 0 and exp_val
+            return random.uniform(0.0, exp_val)
+
+        # Standard Jitter: baseInterval +/- (baseInterval * jitterPercent * random)
+        jitter_sign = -1.0 if random.random() < 0.5 else 1.0
+        jitter_amount = self._base_interval_sec * self._jitter_percent * random.random()
+        return self._base_interval_sec + (jitter_sign * jitter_amount)

subscription_sdk/route_matcher.py

@@ -0,0 +1,63 @@
+import re
+from typing import List, Optional
+from .types import Mapping
+
+class RouteMatcher:
+    @staticmethod
+    def match(method: str, path: str, mappings: List[Mapping]) -> Optional[Mapping]:
+        uppercase_method = method.upper()
+
+        # Sort by priority (ascending, lower priority number takes precedence)
+        sorted_mappings = sorted(mappings, key=lambda m: m.priority)
+
+        for m in sorted_mappings:
+            if m.method.upper() != uppercase_method:
+                continue
+
+            if RouteMatcher._is_match(path, m):
+                return m
+
+        return None
+
+    @staticmethod
+    def _is_match(path: str, mapping: Mapping) -> bool:
+        pattern = mapping.path
+
+        if mapping.matchType == 'exact':
+            return path == pattern
+
+        if mapping.matchType == 'wildcard':
+            # Escape regex special characters like Node SDK
+            # Node pattern: [-\/\\^$*+?.()|[\]{}]
+            special_chars = r'[-\/\\^$*+?.()|[\]{}]'
+            escaped = re.sub(f'({special_chars})', r'\\\1', pattern)
+            
+            # Convert double star wildcard
+            escaped = escaped.replace(r'\*\*', '.*')
+            # Convert single star wildcard
+            escaped = escaped.replace(r'\*', '[^/]*')
+            
+            try:
+                regex = re.compile(f'^{escaped}$')
+                return bool(regex.match(path))
+            except re.error:
+                return False
+
+        if mapping.matchType == 'template':
+            # e.g. /employees/:id -> matches /employees/123
+            segments = pattern.split('/')
+            path_segments = path.split('/')
+
+            if len(segments) != len(path_segments):
+                return False
+
+            for seg, path_seg in zip(segments, path_segments):
+                if seg.startswith(':'):
+                    if path_seg == '':
+                        return False
+                    continue
+                if seg != path_seg:
+                    return False
+            return True
+
+        return False

subscription_sdk/types.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+@dataclass
+class Mapping:
+    id: str
+    method: str
+    path: str
+    matchType: str  # 'exact' | 'template' | 'wildcard'
+    priority: int
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'Mapping':
+        return cls(
+            id=data.get('id', ''),
+            method=data.get('method', ''),
+            path=data.get('path', ''),
+            matchType=data.get('matchType', 'exact'),
+            priority=data.get('priority', 0)
+        )
+
+@dataclass
+class SdkConfig:
+    protocolVersion: str
+    revision: int
+    checksum: str
+    mappings: List[Mapping] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'SdkConfig':
+        mappings_data = data.get('mappings', [])
+        mappings = [Mapping.from_dict(m) for m in mappings_data]
+        return cls(
+            protocolVersion=data.get('protocolVersion', 'v1'),
+            revision=data.get('revision', 0),
+            checksum=data.get('checksum', ''),
+            mappings=mappings
+        )
+
+@dataclass
+class EntitlementCheckResponse:
+    allowed: bool
+    reservationId: Optional[str]
+    featureCode: str
+    remaining: float
+    code: Optional[str] = None
+    detail: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'EntitlementCheckResponse':
+        return cls(
+            allowed=data.get('allowed', False),
+            reservationId=data.get('reservationId'),
+            featureCode=data.get('featureCode', ''),
+            remaining=float(data.get('remaining', 0.0)),
+            code=data.get('code'),
+            detail=data.get('detail')
+        )

subscription_sdk-1.0.0.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: subscription-sdk
+Version: 1.0.0
+Summary: Python Client SDK for Subscription Platform
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: urllib3>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.20.0; extra == "dev"
+Requires-Dist: responses>=0.23.0; extra == "dev"
+Requires-Dist: flask>=2.0.0; extra == "dev"
+Requires-Dist: fastapi>=0.80.0; extra == "dev"
+Requires-Dist: httpx>=0.24.0; extra == "dev"
+Requires-Dist: uvicorn>=0.15.0; extra == "dev"
+
+# subscription-sdk-python
+
+Python SDK for the Subscription and Entitlements Platform.
+
+## Installation
+
+```bash
+pip install subscription-sdk
+```
+
+## Middleware Adapters
+
+### Flask
+
+```python
+from flask import Flask, request, jsonify
+from subscription_sdk.adapters.flask_adapter import subscription_flask
+
+app = Flask(__name__)
+
+# Apply Flask Middleware
+subscription_flask(
+    app,
+    api_key="sub_live_...",
+    base_url="https://api.infosub.io",
+    get_org_id=lambda: request.headers.get("X-Org-Id")
+)
+
+@app.route("/api/v1/employees", methods=["GET"])
+def get_employees():
+    return jsonify({"data": []}), 200
+```
+
+### FastAPI
+
+```python
+from fastapi import FastAPI, Request
+from subscription_sdk.adapters.fastapi_adapter import SubscriptionMiddleware
+
+app = FastAPI()
+
+# Apply FastAPI Middleware
+app.add_middleware(
+    SubscriptionMiddleware,
+    api_key="sub_live_...",
+    base_url="https://api.infosub.io",
+    get_org_id=lambda req: req.headers.get("x-org-id")
+)
+
+@app.get("/api/v1/employees")
+def get_employees(request: Request):
+    return {"data": []}
+```
+
+## Manual Client Usage
+
+```python
+from subscription_sdk import SubscriptionClient
+
+client = SubscriptionClient(api_key="sub_live_...", base_url="https://api.infosub.io")
+client.start()  # Starts background poller thread
+
+mapping = client.match_route("GET", "/api/v1/employees")
+if mapping:
+    check = client.check_entitlement(
+        organization_external_id="tenant-acme",
+        resource_mapping_id=mapping.id,
+        quantity=1.0
+    )
+    if check.allowed:
+        try:
+            # Execute business logic...
+            
+            client.commit_reservation(check.reservationId)
+        except Exception:
+            client.cancel_reservation(check.reservationId)
+```
+
+Alternatively, you can simplify the manual transaction pattern using `.execute(...)`, which handles the check-reserve-commit-cancel flow automatically.
+
+**Basic Example:**
+```python
+# The execute method takes a callback function to run
+result = client.execute(
+    organization_id="tenant-acme",
+    resource_mapping_id=mapping.id,
+    callback=lambda: save_employee(employee),
+    quantity=1.0
+)
+```
+
+**Flask / FastAPI Route Handler Example:**
+```python
+@app.route("/employees-manual", methods=["POST"])
+def create_employee_manual():
+    org_id = request.headers.get("X-Org-Id") or request.args.get("orgId")
+    mapping = client.match_route("POST", "/employees")
+    
+    if not mapping:
+        return jsonify({"error": "Mapping not found"}), 500
+        
+    try:
+        result = client.execute(
+            organization_id=org_id,
+            resource_mapping_id=mapping.id,
+            quantity=1.0,
+            callback=lambda: {
+                "status": "success",
+                "message": "Employee created successfully via manual execute wrapper."
+            }
+        )
+        return jsonify(result), 200
+    except PermissionError as err:
+        # Throws PermissionError if entitlement check is denied (check.allowed is False)
+        return jsonify({"status": "error", "message": str(err)}), 403
+    except Exception as err:
+        return jsonify({"status": "error", "message": str(err)}), 500
+```
+

subscription_sdk-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+subscription_sdk/__init__.py,sha256=wE_FIArq1yreeVU2voprppCLJFQEj_B11paqMg7kr_8,738
+subscription_sdk/client.py,sha256=cvsyJzL0n3KetWnL0E1ZP9t2UX0KO4N2JmbyxsN8c2M,7666
+subscription_sdk/config_manager.py,sha256=XXt6RjDFRLWp_Ry_2MaW86GEq5pXlC2yLCqBrtwyWCo,463
+subscription_sdk/poller.py,sha256=TPVTzMBQwiMmBs7Bzm5gLBxAN8W9tg7PT9jjS3oNTcU,2863
+subscription_sdk/route_matcher.py,sha256=EW6uAPOQtrFnr8UPldqYTsPczy_lPTg_QxmSQDRMC8Q,2043
+subscription_sdk/types.py,sha256=2aPKp_1E-j3sY4BMljZJ0Wpl4x9Q9qxk5dGBT2hhwjQ,1677
+subscription_sdk/adapters/fastapi_adapter.py,sha256=vA2TCPZAguXD_oKZYyRg9Xz0HgD_mwZJtNpwNzsKvas,3906
+subscription_sdk/adapters/flask_adapter.py,sha256=UrNyUpL2N-cla31UtUlqAIvo0FE0Fajf83T3V_vKQsM,2979
+subscription_sdk-1.0.0.dist-info/METADATA,sha256=7hfuC59RGuQn3NXAB_g4hRZKp-7ycHm65-r7VNg98CY,3887
+subscription_sdk-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+subscription_sdk-1.0.0.dist-info/top_level.txt,sha256=vOf5OfXvrSYcUkdUEKHhTVVqDvYnzMBJTkeHpYkGHPk,17
+subscription_sdk-1.0.0.dist-info/RECORD,,

subscription_sdk-1.0.0.dist-info/WHEEL

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

subscription_sdk-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+subscription_sdk