debugbundle-python 0.1.0__py3-none-any.whl

debugbundle/relay.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+DEFAULT_MAX_BODY_BYTES = 262_144
+DEFAULT_RATE_LIMIT_PER_MINUTE = 60
+BROWSER_SDK_NAME = "@debugbundle/sdk-browser"
+
+ACCEPTED_EVENT_TYPES = frozenset(
+    {
+        "frontend_exception",
+        "error_suppressed",
+        "frontend_breadcrumb",
+        "probe_event",
+    }
+)
+
+
+@dataclass(frozen=True)
+class BrowserRelayResponse:
+    status: int
+    body: dict[str, Any] | None = None
+
+
+@dataclass(frozen=True)
+class BrowserRelayAcceptedBatch:
+    events: list[dict[str, Any]]
+    headers: dict[str, str]
+    ip_address: str | None
+    received_at: str
+
+
+@dataclass
+class BrowserRelayHandler:
+    allowed_origins: list[str] = field(default_factory=list)
+    max_body_bytes: int = DEFAULT_MAX_BODY_BYTES
+    rate_limit_per_minute: int = DEFAULT_RATE_LIMIT_PER_MINUTE
+    on_accept: Callable[[BrowserRelayAcceptedBatch], None] | None = None
+
+    def __post_init__(self) -> None:
+        self.allowed_origins = [o for o in self.allowed_origins if o]
+        self.max_body_bytes = max(1, self.max_body_bytes)
+        self.rate_limit_per_minute = max(1, self.rate_limit_per_minute)
+        self._rate_limit_state: dict[str, list[int]] = {}
+
+    def handle(self, request: dict[str, Any]) -> BrowserRelayResponse:
+        method = str(request.get("method", "POST")).upper()
+        if method != "POST":
+            return BrowserRelayResponse(405)
+
+        headers = _normalize_headers(request.get("headers") or {})
+        if not self._is_origin_allowed(headers):
+            return BrowserRelayResponse(403)
+
+        if not _is_supported_content_type(headers.get("content-type")):
+            return BrowserRelayResponse(
+                400,
+                {"accepted": 0, "rejected": 0, "errors": ["Relay requests must use Content-Type: application/json."]},
+            )
+
+        body: str = request.get("body", "")
+        if len(body.encode("utf-8") if isinstance(body, str) else body) > self.max_body_bytes:
+            return BrowserRelayResponse(413)
+
+        ip_address: str | None = request.get("ipAddress") or request.get("ip_address")
+        if self._is_rate_limited(ip_address):
+            return BrowserRelayResponse(429)
+
+        try:
+            decoded = json.loads(body)
+        except (json.JSONDecodeError, TypeError, ValueError):
+            return BrowserRelayResponse(
+                400,
+                {"accepted": 0, "rejected": 0, "errors": ["Relay request body must be valid JSON."]},
+            )
+
+        if not isinstance(decoded, dict):
+            return BrowserRelayResponse(
+                400,
+                {"accepted": 0, "rejected": 0, "errors": ["Relay request body must be valid JSON."]},
+            )
+
+        batch = decoded.get("batch")
+        if not isinstance(batch, list):
+            return BrowserRelayResponse(
+                400,
+                {"accepted": 0, "rejected": 0, "errors": ["Relay request body must include a batch array."]},
+            )
+
+        accepted_events: list[dict[str, Any]] = []
+        errors: list[str] = []
+
+        for index, candidate in enumerate(batch):
+            if not isinstance(candidate, dict):
+                errors.append(f"batch[{index}]: Relay events must be objects.")
+                continue
+
+            event_type = candidate.get("event_type")
+            if not isinstance(event_type, str) or event_type not in ACCEPTED_EVENT_TYPES:
+                type_label = event_type if isinstance(event_type, str) else "unknown"
+                errors.append(f"batch[{index}]: Unsupported browser relay event type {type_label}.")
+                continue
+
+            sanitized = _sanitize_event(candidate)
+            if sanitized is None:
+                errors.append(f"batch[{index}]: Invalid browser relay event payload.")
+                continue
+
+            accepted_events.append(sanitized)
+
+        if accepted_events and self.on_accept is not None:
+            self.on_accept(
+                BrowserRelayAcceptedBatch(
+                    events=accepted_events,
+                    headers=_strip_sensitive_headers(headers),
+                    ip_address=ip_address,
+                    received_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                )
+            )
+
+        if errors:
+            return BrowserRelayResponse(
+                400,
+                {"accepted": len(accepted_events), "rejected": len(errors), "errors": errors},
+            )
+
+        return BrowserRelayResponse(
+            202,
+            {"accepted": len(accepted_events), "rejected": 0, "errors": []},
+        )
+
+    def _is_origin_allowed(self, headers: dict[str, str]) -> bool:
+        origin = _source_origin(headers)
+        if origin is None:
+            return False
+
+        if self.allowed_origins:
+            normalized_origin = _normalize_origin(origin)
+            return any(_normalize_origin(candidate) == normalized_origin for candidate in self.allowed_origins)
+
+        host = headers.get("host")
+        if not host:
+            return False
+
+        try:
+            from urllib.parse import urlparse
+
+            origin_host = urlparse(origin).hostname
+            return isinstance(origin_host, str) and origin_host.lower() == host.lower().split(":")[0]
+        except Exception:
+            return False
+
+    def _is_rate_limited(self, ip_address: str | None) -> bool:
+        key = ip_address or "unknown"
+        now = int(time.time())
+        window_start = now - 60
+        timestamps = [ts for ts in self._rate_limit_state.get(key, []) if ts > window_start]
+
+        if len(timestamps) >= self.rate_limit_per_minute:
+            self._rate_limit_state[key] = timestamps
+            return True
+
+        timestamps.append(now)
+        self._rate_limit_state[key] = timestamps
+        return False
+
+
+def _normalize_headers(headers: dict[str, Any]) -> dict[str, str]:
+    return {str(key).lower(): str(value) for key, value in headers.items()}
+
+
+def _is_supported_content_type(content_type: str | None) -> bool:
+    return isinstance(content_type, str) and "application/json" in content_type.lower()
+
+
+def _source_origin(headers: dict[str, str]) -> str | None:
+    origin = (headers.get("origin") or "").strip()
+    if origin:
+        return origin
+
+    referer = (headers.get("referer") or "").strip()
+    if not referer:
+        return None
+
+    try:
+        from urllib.parse import urlparse
+
+        parsed = urlparse(referer)
+        if parsed.scheme and parsed.hostname:
+            return f"{parsed.scheme}://{parsed.hostname}"
+    except Exception:
+        pass
+
+    return None
+
+
+def _normalize_origin(origin: str) -> str:
+    return origin.strip().lower().rstrip("/")
+
+
+def _strip_sensitive_headers(headers: dict[str, str]) -> dict[str, str]:
+    sanitized = dict(headers)
+    for key in ("authorization", "cookie", "x-api-key"):
+        sanitized.pop(key, None)
+    return sanitized
+
+
+def _sanitize_event(event: dict[str, Any]) -> dict[str, Any] | None:
+    schema_version = event.get("schema_version")
+    event_id = event.get("event_id")
+    event_type = event.get("event_type")
+    occurred_at = event.get("occurred_at")
+    sdk_version = event.get("sdk_version")
+    service = event.get("service")
+    payload = event.get("payload")
+
+    if (
+        not isinstance(schema_version, str)
+        or not schema_version
+        or not isinstance(event_id, str)
+        or not event_id
+        or not isinstance(event_type, str)
+        or not isinstance(occurred_at, str)
+        or not occurred_at
+        or not isinstance(sdk_version, str)
+        or not sdk_version
+        or not isinstance(service, dict)
+        or not isinstance(payload, dict)
+    ):
+        return None
+
+    service_name = service.get("name")
+    environment = service.get("environment")
+    if not isinstance(service_name, str) or not service_name or not isinstance(environment, str) or not environment:
+        return None
+
+    sanitized: dict[str, Any] = {
+        "schema_version": schema_version,
+        "event_id": event_id,
+        "event_type": event_type,
+        "occurred_at": occurred_at,
+        "sdk_name": BROWSER_SDK_NAME,
+        "sdk_version": sdk_version,
+        "service": {
+            "name": service_name,
+            "environment": environment,
+        },
+        "payload": payload,
+    }
+
+    correlation = event.get("correlation")
+    if isinstance(correlation, dict):
+        trace_id = correlation.get("trace_id")
+        if isinstance(trace_id, str) or trace_id is None:
+            sanitized["correlation"] = {"trace_id": trace_id}
+
+    return sanitized

debugbundle/suppression.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from hashlib import sha256
+
+DUPLICATE_WINDOW_SECONDS = 30.0
+LOOP_WINDOW_SECONDS = 2.0
+LOOP_THRESHOLD = 10
+LOOP_RESET_AFTER_SECONDS = 60.0
+LOOP_CHECKPOINT_SECONDS = 30.0
+MAX_NORMAL_EVENTS_PER_WINDOW = 3
+
+
+@dataclass
+class SuppressionState:
+    window_started_at: float
+    emitted_count: int = 0
+    pending_suppressed_count: int = 0
+    pending_first_seen_at: float | None = None
+    pending_last_seen_at: float | None = None
+    last_aggregate_emitted_at: float | None = None
+    loop_window_started_at: float = 0.0
+    loop_hit_count: int = 0
+    suppression_mode: bool = False
+    last_seen_at: float = 0.0
+
+
+class EventSuppressionTracker:
+    def __init__(self) -> None:
+        self._states: dict[str, SuppressionState] = {}
+
+    def should_capture(self, key: str, now: float) -> bool:
+        state = self._states.get(key)
+        if state is None:
+            state = SuppressionState(
+                window_started_at=now,
+                loop_window_started_at=now,
+                last_seen_at=now,
+            )
+            self._states[key] = state
+
+        if state.suppression_mode and now - state.last_seen_at >= LOOP_RESET_AFTER_SECONDS:
+            self._states[key] = SuppressionState(
+                window_started_at=now,
+                loop_window_started_at=now,
+                last_seen_at=now,
+            )
+            state = self._states[key]
+
+        if now - state.window_started_at >= DUPLICATE_WINDOW_SECONDS:
+            state.window_started_at = now
+            state.emitted_count = 0
+
+        if now - state.loop_window_started_at >= LOOP_WINDOW_SECONDS:
+            state.loop_window_started_at = now
+            state.loop_hit_count = 0
+
+        state.loop_hit_count += 1
+        state.last_seen_at = now
+
+        if state.loop_hit_count > LOOP_THRESHOLD:
+            state.suppression_mode = True
+
+        if state.suppression_mode:
+            self._mark_suppressed(state, now)
+            return False
+
+        if state.emitted_count < MAX_NORMAL_EVENTS_PER_WINDOW:
+            state.emitted_count += 1
+            return True
+
+        self._mark_suppressed(state, now)
+        return False
+
+    def drain_aggregates(self, now: float) -> list[dict[str, object]]:
+        aggregates: list[dict[str, object]] = []
+
+        for key, state in self._states.items():
+            if (
+                state.pending_suppressed_count == 0
+                or state.pending_first_seen_at is None
+                or state.pending_last_seen_at is None
+            ):
+                continue
+
+            if (
+                state.suppression_mode
+                and state.last_aggregate_emitted_at is not None
+                and now - state.last_aggregate_emitted_at < LOOP_CHECKPOINT_SECONDS
+            ):
+                continue
+
+            aggregates.append(
+                {
+                    "event_type": "error_suppressed",
+                    "payload": {
+                        "fingerprint": sha256(key.encode("utf-8")).hexdigest(),
+                        "suppressed_count": state.pending_suppressed_count,
+                        "first_seen": _to_iso(state.pending_first_seen_at),
+                        "last_seen": _to_iso(state.pending_last_seen_at),
+                        "window_seconds": int(DUPLICATE_WINDOW_SECONDS),
+                    },
+                }
+            )
+
+            state.pending_suppressed_count = 0
+            state.pending_first_seen_at = None
+            state.pending_last_seen_at = None
+            state.last_aggregate_emitted_at = now
+
+        return aggregates
+
+    @staticmethod
+    def _mark_suppressed(state: SuppressionState, now: float) -> None:
+        if state.pending_suppressed_count == 0:
+            state.pending_first_seen_at = state.window_started_at
+        state.pending_suppressed_count += 1
+        state.pending_last_seen_at = now
+
+
+def _to_iso(timestamp: float) -> str:
+    from datetime import datetime, timezone
+
+    return datetime.fromtimestamp(timestamp, tz=timezone.utc).isoformat().replace("+00:00", "Z")

debugbundle/transport.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+import httpx
+
+
+@dataclass
+class TransportResponse:
+    status_code: int
+    retry_after_ms: int | None = None
+
+
+class Transport(Protocol):
+    def __call__(self, request: Mapping[str, object]) -> TransportResponse:
+        ...
+
+
+class HttpTransport:
+    def __init__(self, endpoint: str) -> None:
+        self._endpoint = endpoint
+        self._client = httpx.Client(timeout=5.0)
+
+    def __call__(self, request: Mapping[str, object]) -> TransportResponse:
+        headers = {
+            "authorization": f"Bearer {request['project_token']}",
+            "content-type": "application/json",
+        }
+        response = self._client.post(
+            self._endpoint,
+            json={"events": request["events"]},
+            headers=headers,
+        )
+        retry_after_header = response.headers.get("retry-after")
+        retry_after_ms = None
+        if retry_after_header is not None:
+            try:
+                retry_after_ms = int(float(retry_after_header) * 1000)
+            except ValueError:
+                retry_after_ms = None
+
+        return TransportResponse(status_code=response.status_code, retry_after_ms=retry_after_ms)
+
+    def close(self) -> None:
+        self._client.close()
+
+
+def coerce_transport_response(response: Any) -> TransportResponse:
+    if isinstance(response, TransportResponse):
+        return response
+
+    status_code = getattr(response, "status_code", None)
+    retry_after_ms = getattr(response, "retry_after_ms", None)
+    if isinstance(status_code, int):
+        return TransportResponse(status_code=status_code, retry_after_ms=retry_after_ms)
+
+    raise TypeError("Unsupported transport response")

debugbundle/trigger_token.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+from typing import Any
+
+from .config import RemoteProbeDirective, _as_non_empty_string, _expires_at_ms
+
+HEADER_NAME = "x-debugbundle-probe-trigger"
+QUERY_PARAMETER_NAME = "_debug_probe"
+TOKEN_PREFIX = "dbundle_probe_"
+
+
+def resolve_request_trigger_directives(
+    request: dict[str, Any] | None,
+    trigger_token_key: str | None,
+    now_ms: int,
+) -> list[RemoteProbeDirective]:
+    if request is None or not trigger_token_key:
+        return []
+
+    token = _extract_trigger_token(request)
+    if token is None or not token.startswith(TOKEN_PREFIX):
+        return []
+
+    encoded = token[len(TOKEN_PREFIX) :]
+    separator_index = encoded.find(".")
+    if separator_index <= 0 or separator_index == len(encoded) - 1:
+        return []
+
+    payload_segment = encoded[:separator_index]
+    signature_segment = encoded[separator_index + 1 :]
+    if not _has_valid_signature(payload_segment, signature_segment, trigger_token_key):
+        return []
+
+    payload = _decode_payload_segment(payload_segment)
+    if payload is None or _expires_at_ms(payload["trigger_expires_at"]) <= now_ms:
+        return []
+
+    return [
+        RemoteProbeDirective(
+            id=payload["activation_id"],
+            label_pattern=payload["label_pattern"],
+            service=payload["service"],
+            environment=payload["environment"],
+            expires_at=payload["trigger_expires_at"],
+        )
+    ]
+
+
+def _extract_trigger_token(request: dict[str, Any]) -> str | None:
+    headers = request.get("headers")
+    if isinstance(headers, dict):
+        header_token = _extract_map_value(headers, HEADER_NAME, case_insensitive=True)
+        if header_token is not None:
+            return header_token
+
+    query = request.get("query")
+    if isinstance(query, dict):
+        return _extract_map_value(query, QUERY_PARAMETER_NAME, case_insensitive=False)
+
+    return None
+
+
+def _decode_payload_segment(payload_segment: str) -> dict[str, str] | None:
+    try:
+        decoded = _base64url_decode(payload_segment)
+        if decoded is None:
+            return None
+        parsed = json.loads(decoded)
+    except Exception:
+        return None
+
+    if not isinstance(parsed, dict):
+        return None
+
+    activation_id = _as_non_empty_string(parsed.get("activation_id"))
+    label_pattern = _as_non_empty_string(parsed.get("label_pattern"))
+    service = _as_non_empty_string(parsed.get("service"))
+    environment = _as_non_empty_string(parsed.get("environment"))
+    expires_at = _as_non_empty_string(parsed.get("trigger_expires_at"))
+
+    if activation_id is None or label_pattern is None or service is None or environment is None or expires_at is None:
+        return None
+
+    if _expires_at_ms(expires_at) == 0:
+        return None
+
+    return {
+        "activation_id": activation_id,
+        "label_pattern": label_pattern,
+        "service": service,
+        "environment": environment,
+        "trigger_expires_at": expires_at,
+    }
+
+
+def _has_valid_signature(payload_segment: str, signature_segment: str, trigger_token_key: str) -> bool:
+    expected = hmac.new(trigger_token_key.encode("utf-8"), payload_segment.encode("utf-8"), hashlib.sha256).digest()
+    actual = _base64url_decode_bytes(signature_segment)
+    if actual is None or len(expected) != len(actual):
+        return False
+    return hmac.compare_digest(expected, actual)
+
+
+def _extract_map_value(mapping: dict[str, Any], key: str, *, case_insensitive: bool) -> str | None:
+    for candidate_key, value in mapping.items():
+        if case_insensitive:
+            matches = str(candidate_key).lower() == key.lower()
+        else:
+            matches = str(candidate_key) == key
+
+        if not matches:
+            continue
+
+        if isinstance(value, str) and value:
+            return value
+
+        if isinstance(value, (list, tuple)):
+            for entry in value:
+                if isinstance(entry, str) and entry:
+                    return entry
+
+    return None
+
+
+def _base64url_decode(value: str) -> str | None:
+    raw = _base64url_decode_bytes(value)
+    if raw is None:
+        return None
+    return raw.decode("utf-8")
+
+
+def _base64url_decode_bytes(value: str) -> bytes | None:
+    try:
+        padding = len(value) % 4
+        if padding > 0:
+            value += "=" * (4 - padding)
+        return base64.urlsafe_b64decode(value)
+    except Exception:
+        return None

debugbundle_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: debugbundle-python
+Version: 0.1.0
+Summary: DebugBundle SDK for Python
+Author: DebugBundle
+License-Expression: AGPL-3.0-only
+Project-URL: Homepage, https://debugbundle.com/docs/sdk-python
+Project-URL: Repository, https://github.com/debugbundle/debugbundle-python
+Project-URL: Issues, https://github.com/debugbundle/debugbundle-python/issues
+Keywords: debugbundle,debugging,ai-agent,error-tracking
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Flask
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<0.29,>=0.27
+Provides-Extra: dev
+Requires-Dist: build<2,>=1; extra == "dev"
+Requires-Dist: django<6,>=5; extra == "dev"
+Requires-Dist: fastapi<1,>=0.115; extra == "dev"
+Requires-Dist: flask<4,>=3; extra == "dev"
+Requires-Dist: jsonschema<5,>=4.23; extra == "dev"
+Requires-Dist: loguru<1,>=0.7; extra == "dev"
+Requires-Dist: mypy<2,>=1.15; extra == "dev"
+Requires-Dist: pytest<9,>=8.3; extra == "dev"
+Requires-Dist: pytest-cov<7,>=5; extra == "dev"
+Requires-Dist: ruff<0.12,>=0.11; extra == "dev"
+Requires-Dist: structlog<26,>=24; extra == "dev"
+Requires-Dist: twine<7,>=5; extra == "dev"
+Dynamic: license-file
+
+# debugbundle-python
+
+DebugBundle SDK for Python.
+
+## Installation
+
+```bash
+pip install debugbundle-python
+```
+
+## Quick Start
+
+```python
+import debugbundle
+
+debugbundle.init(project_token="dbundle_proj_test", service="checkout-api")
+debugbundle.capture_exception(RuntimeError("boom"))
+debugbundle.flush()
+```
+
+## Status
+
+This repository currently contains the full Phase 18 Python SDK scope in eleven implementation slices: core SDK surface, buffering, redaction, duplicate suppression, probe buffering, vanilla runtime hooks, framework integrations for Django, Flask, and FastAPI, remote config polling and capture-policy enforcement, optional `structlog` and `loguru` auto-detection when `capture_logging()` is enabled, contract-aligned `EventEnvelope` emission for log, request, exception, suppression, and probe payloads, explicit public wrapper signatures and a validated buildable typed package artifact, real HTTP integration coverage against a lightweight mock ingestion server, vendored machine-readable schema validation for all event types the Python SDK currently emits, a standalone CI workflow that validates Ruff, mypy, pytest, and package builds for the Python 3.10+ support floor actually used by the package, an enforced per-file coverage gate that keeps every shipped Python SDK module at or above the required 80% minimum, and request-local framework correlation binding so `X-DebugBundle-Trace-Id` flows through Django, Flask, and FastAPI into the emitted event correlation metadata for cross-context linking.
+
+## Docs
+
+https://debugbundle.com/docs/sdk-python

debugbundle_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+debugbundle/__init__.py,sha256=mqibduUrdcr_fnb6k3Gwf93H7iqVBS8zd6SceX-U3Q4,5011
+debugbundle/config.py,sha256=tmXJc16v9yzldiyp1Fwo2s0j-Ek-wbKx__BeKaNw9ec,6097
+debugbundle/core.py,sha256=CTx3MmJv0x3fZr0IqTqliv0slTqmia9QVb6eEm4RPTQ,32628
+debugbundle/logger_integrations.py,sha256=RuTNaD9RRVmiE-BBkksAXWVEGaMzLrWavVpQdgGZBpE,4564
+debugbundle/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+debugbundle/redaction.py,sha256=QTaPkSsYv54yR1mz8SB6Q4vWjvp7Ddcui4WXaH2RVz8,736
+debugbundle/relay.py,sha256=q7WjESsIGoaHETQGhWuT-4KdBmXAocuoCLXuEaz9f60,8678
+debugbundle/suppression.py,sha256=XMn0GfF_-WZk2wHWk3KfbO5_u5QhEunues5h3jOInLs,4098
+debugbundle/transport.py,sha256=oOk0xazHxq9h4CneJdRODKtwDciwikvpHVJM_6iBYXU,1791
+debugbundle/trigger_token.py,sha256=YUwIWnnxu1klAVaB8Ltgk_PwWW_PPjq9rzmEbWXeFeM,4455
+debugbundle/integrations/__init__.py,sha256=VVNoL30a9yd26U9oH1CQMw0_0O0Apo-ZNK1dyrMjTQg,551
+debugbundle/integrations/common.py,sha256=iiwf5wDlpujFuWfbO-ziFTn4MtiHBXSIZNXtamhCavg,2014
+debugbundle/integrations/django.py,sha256=vDQGc0ObcHCe4NQbC0ijcXUM-y9GzOVBjDtcHzxyrxw,1828
+debugbundle/integrations/fastapi.py,sha256=-054Z6MogkZIqKR8DHR4jm2nNC5yyZ5vtanpw6g-voE,3414
+debugbundle/integrations/flask.py,sha256=cgyHbsAH96gpNPf_5IGJYzp2va28JdDgXROBsF-Fbyo,2390
+debugbundle/integrations/relay_django.py,sha256=_2TiH-oS0DOwThyfMJZ6ZJr5MkXEekEDaBUfPapMxt8,1523
+debugbundle/integrations/relay_fastapi.py,sha256=Z2spWy3wufVrBjYwRDDOL5Dsjgwcd5g72L23_sdulvo,1512
+debugbundle/integrations/relay_flask.py,sha256=WHk_ALOtT0xUuI1eINWFyLig9eRjSmIBpQ39xdkV608,1329
+debugbundle_python-0.1.0.dist-info/licenses/LICENSE,sha256=AKZZ5DQAHrOKGwt24VoRd-SXJLM9OloxlsX8ZgENdEY,735
+debugbundle_python-0.1.0.dist-info/METADATA,sha256=LtOnh1fp34Nt1M6Cl-K3DO9IJNEjyj6q3OXmAU9VFv4,3148
+debugbundle_python-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+debugbundle_python-0.1.0.dist-info/top_level.txt,sha256=RCB9STTFnl1OKdojxz-xhaks2zkRFs1meZXsKnm18LM,12
+debugbundle_python-0.1.0.dist-info/RECORD,,

debugbundle_python-0.1.0.dist-info/WHEEL

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