mbuzz 0.1.0__py3-none-any.whl

mbuzz/__init__.py

@@ -0,0 +1,87 @@
+"""Mbuzz - Multi-touch attribution SDK for Python."""
+
+from typing import Any, Dict, Optional, Union
+
+from .config import config
+from .context import get_context
+from .client.track import track, TrackResult
+from .client.identify import identify
+from .client.conversion import conversion, ConversionResult
+
+__version__ = "0.1.0"
+
+
+def init(
+    api_key: str,
+    api_url: Optional[str] = None,
+    enabled: bool = True,
+    debug: bool = False,
+    timeout: Optional[float] = None,
+    skip_paths: Optional[list] = None,
+    skip_extensions: Optional[list] = None,
+) -> None:
+    """Initialize the mbuzz SDK.
+
+    Args:
+        api_key: Your mbuzz API key (required)
+        api_url: API endpoint URL (default: https://mbuzz.co/api/v1)
+        enabled: Enable/disable tracking (default: True)
+        debug: Enable debug logging (default: False)
+        timeout: Request timeout in seconds (default: 5.0)
+        skip_paths: Additional paths to skip tracking
+        skip_extensions: Additional file extensions to skip
+    """
+    config.init(
+        api_key=api_key,
+        api_url=api_url,
+        enabled=enabled,
+        debug=debug,
+        timeout=timeout,
+        skip_paths=skip_paths or [],
+        skip_extensions=skip_extensions or [],
+    )
+
+
+def event(event_type: str, **properties: Any) -> TrackResult:
+    """Track an event.
+
+    Args:
+        event_type: Type of event (e.g., "page_view", "button_click")
+        **properties: Additional event properties
+
+    Returns:
+        TrackResult with success status and event details
+    """
+    return track(event_type=event_type, properties=properties)
+
+
+def visitor_id() -> Optional[str]:
+    """Get current visitor ID from context."""
+    ctx = get_context()
+    return ctx.visitor_id if ctx else None
+
+
+def session_id() -> Optional[str]:
+    """Get current session ID from context."""
+    ctx = get_context()
+    return ctx.session_id if ctx else None
+
+
+def user_id() -> Optional[str]:
+    """Get current user ID from context."""
+    ctx = get_context()
+    return ctx.user_id if ctx else None
+
+
+__all__ = [
+    "init",
+    "event",
+    "conversion",
+    "identify",
+    "visitor_id",
+    "session_id",
+    "user_id",
+    "TrackResult",
+    "ConversionResult",
+    "__version__",
+]

mbuzz/api.py

@@ -0,0 +1,71 @@
+"""HTTP client for mbuzz API communication."""
+
+import json
+import logging
+from typing import Any, Dict, Optional
+from urllib.request import Request, urlopen
+from urllib.error import URLError, HTTPError
+
+from .config import config
+
+logger = logging.getLogger("mbuzz")
+
+VERSION = "0.1.0"
+
+
+def post(path: str, payload: Dict[str, Any]) -> bool:
+    """POST to API, return True on success, False on any failure.
+
+    Never raises exceptions - all errors are caught and logged.
+    """
+    if not config._initialized or not config.enabled:
+        return False
+
+    try:
+        response = _make_request(path, payload)
+        return 200 <= response.status < 300
+    except Exception as e:
+        if config.debug:
+            logger.error(f"mbuzz API error: {e}")
+        return False
+
+
+def post_with_response(path: str, payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """POST to API, return parsed JSON on success, None on failure.
+
+    Never raises exceptions - all errors are caught and logged.
+    """
+    if not config._initialized or not config.enabled:
+        return None
+
+    try:
+        response = _make_request(path, payload)
+        if 200 <= response.status < 300:
+            body = response.read().decode("utf-8")
+            if config.debug:
+                logger.debug(f"mbuzz response: {body}")
+            return json.loads(body)
+        return None
+    except Exception as e:
+        if config.debug:
+            logger.error(f"mbuzz API error: {e}")
+        return None
+
+
+def _make_request(path: str, payload: Dict[str, Any]):
+    """Make HTTP request to API."""
+    base_url = config.api_url.rstrip("/")
+    clean_path = path.lstrip("/")
+    url = f"{base_url}/{clean_path}"
+
+    data = json.dumps(payload).encode("utf-8")
+
+    req = Request(url, data=data, method="POST")
+    req.add_header("Authorization", f"Bearer {config.api_key}")
+    req.add_header("Content-Type", "application/json")
+    req.add_header("User-Agent", f"mbuzz-python/{VERSION}")
+
+    if config.debug:
+        logger.debug(f"mbuzz POST {url}: {payload}")
+
+    return urlopen(req, timeout=config.timeout)

mbuzz/client/__init__.py

@@ -0,0 +1 @@
+"""Client module - stub for TDD."""

mbuzz/client/conversion.py

@@ -0,0 +1,74 @@
+"""Conversion request for tracking conversions."""
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Union
+
+from ..api import post_with_response
+from ..context import get_context
+
+
+@dataclass
+class ConversionResult:
+    """Result of tracking a conversion."""
+
+    success: bool
+    conversion_id: Optional[str] = None
+    attribution: Optional[Dict[str, Any]] = None
+
+
+def conversion(
+    conversion_type: str,
+    visitor_id: Optional[str] = None,
+    user_id: Optional[Union[str, int]] = None,
+    event_id: Optional[str] = None,
+    revenue: Optional[float] = None,
+    currency: str = "USD",
+    is_acquisition: bool = False,
+    inherit_acquisition: bool = False,
+    properties: Optional[Dict[str, Any]] = None,
+) -> ConversionResult:
+    """Track a conversion.
+
+    Args:
+        conversion_type: Type of conversion (e.g., "purchase", "signup")
+        visitor_id: Visitor ID (uses context if not provided)
+        user_id: User ID (uses context if not provided)
+        event_id: Optional event ID to link conversion to
+        revenue: Revenue amount
+        currency: Currency code (default: USD)
+        is_acquisition: Whether this is a customer acquisition
+        inherit_acquisition: Whether to inherit acquisition from previous conversion
+        properties: Additional conversion properties
+
+    Returns:
+        ConversionResult with success status, conversion ID, and attribution data
+    """
+    ctx = get_context()
+
+    visitor_id = visitor_id or (ctx.visitor_id if ctx else None)
+    user_id = user_id or (ctx.user_id if ctx else None)
+
+    if not visitor_id and not user_id:
+        return ConversionResult(success=False)
+
+    payload = {
+        "conversion_type": conversion_type,
+        "visitor_id": visitor_id,
+        "user_id": str(user_id) if user_id else None,
+        "event_id": event_id,
+        "revenue": revenue,
+        "currency": currency,
+        "is_acquisition": is_acquisition,
+        "inherit_acquisition": inherit_acquisition,
+        "properties": properties or {},
+    }
+
+    response = post_with_response("/conversions", payload)
+    if not response:
+        return ConversionResult(success=False)
+
+    return ConversionResult(
+        success=True,
+        conversion_id=response.get("conversion", {}).get("id"),
+        attribution=response.get("attribution"),
+    )

mbuzz/client/identify.py

@@ -0,0 +1,36 @@
+"""Identify request for user identification."""
+
+from typing import Any, Dict, Optional, Union
+
+from ..api import post
+from ..context import get_context
+
+
+def identify(
+    user_id: Union[str, int, None],
+    visitor_id: Optional[str] = None,
+    traits: Optional[Dict[str, Any]] = None,
+) -> bool:
+    """Identify a user and link to visitor.
+
+    Args:
+        user_id: User ID to identify (required)
+        visitor_id: Visitor ID (uses context if not provided)
+        traits: User traits/attributes
+
+    Returns:
+        True on success, False on failure
+    """
+    if not user_id:
+        return False
+
+    ctx = get_context()
+    visitor_id = visitor_id or (ctx.visitor_id if ctx else None)
+
+    payload = {
+        "user_id": str(user_id),
+        "visitor_id": visitor_id,
+        "traits": traits or {},
+    }
+
+    return post("/identify", payload)

mbuzz/client/session.py

@@ -0,0 +1,38 @@
+"""Session request for creating sessions."""
+
+from datetime import datetime, timezone
+from typing import Optional
+
+from ..api import post
+
+
+def create_session(
+    visitor_id: str,
+    session_id: str,
+    url: str,
+    referrer: Optional[str] = None,
+) -> bool:
+    """Create a new session.
+
+    Called async from middleware on first request.
+
+    Args:
+        visitor_id: Visitor ID
+        session_id: Session ID
+        url: Current page URL
+        referrer: Referring URL
+
+    Returns:
+        True on success, False on failure
+    """
+    payload = {
+        "session": {
+            "visitor_id": visitor_id,
+            "session_id": session_id,
+            "url": url,
+            "referrer": referrer,
+            "started_at": datetime.now(timezone.utc).isoformat(),
+        }
+    }
+
+    return post("/sessions", payload)

mbuzz/client/track.py

@@ -0,0 +1,130 @@
+"""Track request for event tracking."""
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from ..api import post_with_response
+from ..context import get_context
+
+
+@dataclass
+class TrackResult:
+    """Result of tracking an event."""
+
+    success: bool
+    event_id: Optional[str] = None
+    event_type: Optional[str] = None
+    visitor_id: Optional[str] = None
+    session_id: Optional[str] = None
+
+
+@dataclass
+class TrackOptions:
+    """Options for tracking an event."""
+
+    event_type: str
+    visitor_id: Optional[str] = None
+    session_id: Optional[str] = None
+    user_id: Optional[str] = None
+    properties: Optional[Dict[str, Any]] = None
+
+
+def _resolve_ids(options: TrackOptions) -> TrackOptions:
+    """Resolve visitor/session/user IDs from context if not provided."""
+    ctx = get_context()
+    if not ctx:
+        return options
+
+    return TrackOptions(
+        event_type=options.event_type,
+        visitor_id=options.visitor_id or ctx.visitor_id,
+        session_id=options.session_id or ctx.session_id,
+        user_id=options.user_id or ctx.user_id,
+        properties=options.properties,
+    )
+
+
+def _enrich_properties(options: TrackOptions) -> Dict[str, Any]:
+    """Enrich properties with url/referrer from context."""
+    ctx = get_context()
+    props = options.properties or {}
+
+    if ctx:
+        return ctx.enrich_properties(props)
+    return props
+
+
+def _validate(options: TrackOptions) -> bool:
+    """Validate track options. Must have visitor_id or user_id."""
+    return bool(options.visitor_id or options.user_id)
+
+
+def _build_payload(options: TrackOptions, properties: Dict[str, Any]) -> Dict[str, Any]:
+    """Build API payload from options."""
+    return {
+        "events": [
+            {
+                "event_type": options.event_type,
+                "visitor_id": options.visitor_id,
+                "session_id": options.session_id,
+                "user_id": options.user_id,
+                "properties": properties,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+        ]
+    }
+
+
+def _parse_response(response: Optional[Dict[str, Any]], options: TrackOptions) -> TrackResult:
+    """Parse API response into TrackResult."""
+    if not response or not response.get("events"):
+        return TrackResult(success=False)
+
+    event = response["events"][0]
+    return TrackResult(
+        success=True,
+        event_id=event.get("id"),
+        event_type=options.event_type,
+        visitor_id=options.visitor_id,
+        session_id=options.session_id,
+    )
+
+
+def track(
+    event_type: str,
+    visitor_id: Optional[str] = None,
+    session_id: Optional[str] = None,
+    user_id: Optional[str] = None,
+    properties: Optional[Dict[str, Any]] = None,
+) -> TrackResult:
+    """Track an event.
+
+    Args:
+        event_type: Type of event (e.g., "page_view", "button_click")
+        visitor_id: Visitor ID (uses context if not provided)
+        session_id: Session ID (uses context if not provided)
+        user_id: User ID (uses context if not provided)
+        properties: Additional event properties
+
+    Returns:
+        TrackResult with success status and event details
+    """
+    options = TrackOptions(
+        event_type=event_type,
+        visitor_id=visitor_id,
+        session_id=session_id,
+        user_id=user_id,
+        properties=properties,
+    )
+
+    options = _resolve_ids(options)
+
+    if not _validate(options):
+        return TrackResult(success=False)
+
+    enriched_props = _enrich_properties(options)
+    payload = _build_payload(options, enriched_props)
+    response = post_with_response("/events", payload)
+
+    return _parse_response(response, options)

mbuzz/config.py

@@ -0,0 +1,96 @@
+"""Configuration management for mbuzz SDK."""
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+DEFAULT_API_URL = "https://mbuzz.co/api/v1"
+DEFAULT_TIMEOUT = 5.0
+
+DEFAULT_SKIP_PATHS = [
+    "/health",
+    "/healthz",
+    "/ping",
+    "/up",
+    "/static",
+    "/assets",
+    "/media",
+    "/admin/jsi18n",
+    "/__debug__",
+]
+
+DEFAULT_SKIP_EXTENSIONS = [
+    ".js",
+    ".css",
+    ".map",
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".ico",
+    ".svg",
+    ".webp",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+]
+
+
+@dataclass
+class Config:
+    """SDK configuration singleton."""
+
+    api_key: str = ""
+    api_url: str = DEFAULT_API_URL
+    enabled: bool = True
+    debug: bool = False
+    timeout: float = DEFAULT_TIMEOUT
+    skip_paths: List[str] = field(default_factory=list)
+    skip_extensions: List[str] = field(default_factory=list)
+    _initialized: bool = False
+
+    def init(
+        self,
+        api_key: str,
+        api_url: Optional[str] = None,
+        enabled: bool = True,
+        debug: bool = False,
+        timeout: Optional[float] = None,
+        skip_paths: Optional[List[str]] = None,
+        skip_extensions: Optional[List[str]] = None,
+    ) -> None:
+        """Initialize configuration."""
+        if not api_key:
+            raise ValueError("api_key is required")
+
+        self.api_key = api_key
+        self.api_url = api_url or DEFAULT_API_URL
+        self.enabled = enabled
+        self.debug = debug
+        self.timeout = timeout or DEFAULT_TIMEOUT
+        self.skip_paths = DEFAULT_SKIP_PATHS + (skip_paths or [])
+        self.skip_extensions = DEFAULT_SKIP_EXTENSIONS + (skip_extensions or [])
+        self._initialized = True
+
+    def should_skip_path(self, path: str) -> bool:
+        """Check if path should be skipped from tracking."""
+        if any(path.startswith(skip) for skip in self.skip_paths):
+            return True
+        if any(path.endswith(ext) for ext in self.skip_extensions):
+            return True
+        return False
+
+    def reset(self) -> None:
+        """Reset configuration (for testing)."""
+        self.api_key = ""
+        self.api_url = DEFAULT_API_URL
+        self.enabled = True
+        self.debug = False
+        self.timeout = DEFAULT_TIMEOUT
+        self.skip_paths = []
+        self.skip_extensions = []
+        self._initialized = False
+
+
+# Singleton instance
+config = Config()

mbuzz/context.py

@@ -0,0 +1,45 @@
+"""Request context management using contextvars."""
+
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class RequestContext:
+    """Holds request-scoped data for tracking."""
+
+    visitor_id: str
+    session_id: str
+    user_id: Optional[str] = None
+    url: Optional[str] = None
+    referrer: Optional[str] = None
+
+    def enrich_properties(self, properties: Dict[str, Any]) -> Dict[str, Any]:
+        """Add url and referrer to properties if not already present."""
+        result: Dict[str, Any] = {}
+        if self.url:
+            result["url"] = self.url
+        if self.referrer:
+            result["referrer"] = self.referrer
+        result.update(properties)
+        return result
+
+
+# Context variable for current request
+_context: ContextVar[Optional[RequestContext]] = ContextVar("mbuzz_context", default=None)
+
+
+def get_context() -> Optional[RequestContext]:
+    """Get the current request context."""
+    return _context.get()
+
+
+def set_context(ctx: RequestContext) -> None:
+    """Set the current request context."""
+    _context.set(ctx)
+
+
+def clear_context() -> None:
+    """Clear the current request context."""
+    _context.set(None)

mbuzz/cookies.py

@@ -0,0 +1,7 @@
+"""Cookie constants for mbuzz SDK."""
+
+VISITOR_COOKIE = "_mbuzz_vid"
+SESSION_COOKIE = "_mbuzz_sid"
+
+VISITOR_MAX_AGE = 63072000  # 2 years in seconds
+SESSION_MAX_AGE = 1800  # 30 minutes in seconds

mbuzz/middleware/__init__.py

@@ -0,0 +1 @@
+"""Middleware for web frameworks."""

mbuzz/middleware/flask.py

@@ -0,0 +1,119 @@
+"""Flask middleware for mbuzz tracking."""
+
+import threading
+from flask import Flask, request, g, Response
+from typing import Optional
+
+from ..config import config
+from ..context import RequestContext, set_context, clear_context
+from ..cookies import VISITOR_COOKIE, SESSION_COOKIE, VISITOR_MAX_AGE, SESSION_MAX_AGE
+from ..utils.identifier import generate_id
+from ..client.session import create_session
+
+
+def init_app(app: Flask) -> None:
+    """Initialize mbuzz tracking for Flask app."""
+
+    @app.before_request
+    def before_request():
+        if _should_skip():
+            return
+
+        visitor_id = _get_or_create_visitor_id()
+        session_id = _get_or_create_session_id()
+        is_new_session = SESSION_COOKIE not in request.cookies
+
+        _set_request_context(visitor_id, session_id)
+        _store_in_g(visitor_id, session_id, is_new_session)
+        _create_session_if_new(visitor_id, session_id, is_new_session)
+
+    @app.after_request
+    def after_request(response: Response) -> Response:
+        if not hasattr(g, "mbuzz_visitor_id"):
+            return response
+
+        _set_cookies(response)
+        return response
+
+    @app.teardown_request
+    def teardown_request(exception=None):
+        clear_context()
+
+
+def _should_skip() -> bool:
+    """Check if request should skip tracking."""
+    if not config._initialized or not config.enabled:
+        return True
+    if config.should_skip_path(request.path):
+        return True
+    return False
+
+
+def _get_or_create_visitor_id() -> str:
+    """Get visitor ID from cookie or generate new one."""
+    return request.cookies.get(VISITOR_COOKIE) or generate_id()
+
+
+def _get_or_create_session_id() -> str:
+    """Get session ID from cookie or generate new one."""
+    return request.cookies.get(SESSION_COOKIE) or generate_id()
+
+
+def _set_request_context(visitor_id: str, session_id: str) -> None:
+    """Set request context for tracking calls."""
+    ctx = RequestContext(
+        visitor_id=visitor_id,
+        session_id=session_id,
+        user_id=None,
+        url=request.url,
+        referrer=request.referrer,
+    )
+    set_context(ctx)
+
+
+def _store_in_g(visitor_id: str, session_id: str, is_new_session: bool) -> None:
+    """Store tracking IDs in Flask g object for after_request."""
+    g.mbuzz_visitor_id = visitor_id
+    g.mbuzz_session_id = session_id
+    g.mbuzz_is_new_visitor = VISITOR_COOKIE not in request.cookies
+    g.mbuzz_is_new_session = is_new_session
+
+
+def _create_session_if_new(visitor_id: str, session_id: str, is_new_session: bool) -> None:
+    """Create session asynchronously if new session."""
+    if not is_new_session:
+        return
+
+    ctx = RequestContext(
+        visitor_id=visitor_id,
+        session_id=session_id,
+        url=request.url,
+        referrer=request.referrer,
+    )
+    threading.Thread(
+        target=create_session,
+        args=(visitor_id, session_id, ctx.url, ctx.referrer),
+        daemon=True
+    ).start()
+
+
+def _set_cookies(response: Response) -> None:
+    """Set visitor and session cookies on response."""
+    secure = request.is_secure
+
+    response.set_cookie(
+        VISITOR_COOKIE,
+        g.mbuzz_visitor_id,
+        max_age=VISITOR_MAX_AGE,
+        httponly=True,
+        samesite="Lax",
+        secure=secure,
+    )
+    response.set_cookie(
+        SESSION_COOKIE,
+        g.mbuzz_session_id,
+        max_age=SESSION_MAX_AGE,
+        httponly=True,
+        samesite="Lax",
+        secure=secure,
+    )

mbuzz/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Utility functions for mbuzz SDK."""
+
+from .identifier import generate_id
+
+__all__ = ["generate_id"]

mbuzz/utils/identifier.py

@@ -0,0 +1,8 @@
+"""ID generation utilities."""
+
+import secrets
+
+
+def generate_id() -> str:
+    """Generate 64-character hex string (256 bits of entropy)."""
+    return secrets.token_hex(32)

mbuzz-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: mbuzz
+Version: 0.1.0
+Summary: Multi-touch attribution SDK for Python
+Project-URL: Homepage, https://mbuzz.co
+Project-URL: Documentation, https://mbuzz.co/docs/getting-started
+Project-URL: Repository, https://github.com/mbuzzco/mbuzz-python
+Author-email: Mbuzz <support@mbuzz.co>
+License-Expression: MIT
+Keywords: analytics,attribution,marketing,tracking
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Flask
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: django
+Provides-Extra: fastapi
+Requires-Dist: starlette; extra == 'fastapi'
+Provides-Extra: flask
+Description-Content-Type: text/markdown
+
+# mbuzz-python
+
+Python SDK for mbuzz multi-touch attribution.
+
+## Installation
+
+```bash
+pip install mbuzz
+```
+
+## Quick Start
+
+```python
+import mbuzz
+
+# Initialize (once on app start)
+mbuzz.init(api_key="sk_live_...")
+
+# Track events
+mbuzz.event("page_view", url="/pricing")
+
+# Track conversions
+mbuzz.conversion("purchase", revenue=99.99)
+
+# Identify users
+mbuzz.identify("user_123", traits={"email": "user@example.com"})
+```
+
+## Documentation
+
+See [mbuzz.co/docs/getting-started](https://mbuzz.co/docs/getting-started) for full documentation.

mbuzz-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+mbuzz/__init__.py,sha256=zZls_Zf7HfuCFUYnsG2e2mkvDNCioX0togiHom8kyUg,2247
+mbuzz/api.py,sha256=BITkW6TQEGmPA0OmYFFC611X6JWiY6C1dY-_wsKDT2U,2107
+mbuzz/config.py,sha256=u6v1WnMTgiqyDXHszlXw5hyNENgYRy7-z-IWKuYp0-o,2399
+mbuzz/context.py,sha256=l_mwJg9rcmJ0viz9xTFvI5JP8Imohv5o6EjduAnBCNw,1224
+mbuzz/cookies.py,sha256=MCpMljQXaqJ2bhEtTv1aKR2fuqLfGBFofjPRayAQGpw,197
+mbuzz/client/__init__.py,sha256=oNOTpPKdt-b_VH_f848OQTbEEDFhlpbEjZ-WjKvh3JI,36
+mbuzz/client/conversion.py,sha256=Ua3ngFWmH6ekm3ZanNf5up_jV8t5nf788ipM1usvZoM,2346
+mbuzz/client/identify.py,sha256=duyd-OWdBo4w7-7Nv5X-GeG2IpMI-1G_kYwnDXup0FE,859
+mbuzz/client/session.py,sha256=mk8v892bvpeW-VNKFQYDsW442w881yfXBiM4sr9a0SU,835
+mbuzz/client/track.py,sha256=-leW3yJcg9Vm6dL7fLQvFwgUN-nZF-OmDRMeR_9Blz8,3725
+mbuzz/middleware/__init__.py,sha256=gIjwTArToaQNB2NC0iPE_RcmzuHjH7-7jjd7_Dyq4Pw,37
+mbuzz/middleware/flask.py,sha256=dRn8rnOTSrd0w7GjwzjxFFFGuCe7J84MvaNGTT5w4_k,3453
+mbuzz/utils/__init__.py,sha256=-ejtRN6CTkV3D8uujDtAPDoMT0DAG-ULpWOF-Ae55dY,103
+mbuzz/utils/identifier.py,sha256=iAYmd4he2RTtTNlmszb6KQmD9McZbSMgZZdkMuoGOCE,174
+mbuzz-0.1.0.dist-info/METADATA,sha256=HvgtdBRMTA3QqdpOrlkMUqIMoeq5LKnYPUuNrnwF9Hs,1849
+mbuzz-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mbuzz-0.1.0.dist-info/RECORD,,

mbuzz-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any