reflex-junction 0.1.0__py3-none-any.whl

reflex_junction/__init__.py

@@ -0,0 +1,33 @@
+__version__ = "0.1.0"
+
+from .fastapi_helpers import (
+    create_webhook_router,
+    register_webhook_api,
+)
+from .junction_provider import (
+    JunctionState,
+    JunctionUser,
+    junction_provider,
+    on_load,
+    register_on_auth_change_handler,
+    wrap_app,
+)
+from .models import (
+    JunctionConfig,
+    LinkConfig,
+    ProviderInfo,
+)
+
+__all__ = [
+    "JunctionConfig",
+    "JunctionState",
+    "JunctionUser",
+    "LinkConfig",
+    "ProviderInfo",
+    "create_webhook_router",
+    "junction_provider",
+    "on_load",
+    "register_on_auth_change_handler",
+    "register_webhook_api",
+    "wrap_app",
+]

reflex_junction/base.py

@@ -0,0 +1,7 @@
+import reflex as rx
+
+
+class JunctionBase(rx.Component):
+    """Base component for Junction health data integration."""
+
+    library = "@tryvital/vital-link"

reflex_junction/fastapi_helpers.py

@@ -0,0 +1,83 @@
+"""FastAPI helpers for Junction webhook handling."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Sequence
+from typing import Any
+
+import reflex as rx
+from fastapi import APIRouter, FastAPI, Request
+from fastapi.responses import JSONResponse
+
+logger = logging.getLogger(__name__)
+
+
+def create_webhook_router(
+    prefix: str = "/junction",
+    secret: str = "",
+    tags: Sequence[str] | None = None,
+) -> APIRouter:
+    """Create a FastAPI router for Junction webhook handling.
+
+    Args:
+        prefix: URL prefix for webhook endpoints.
+        secret: Svix webhook signing secret for signature verification.
+        tags: OpenAPI tags for the router.
+
+    Returns:
+        A FastAPI APIRouter with webhook endpoints.
+    """
+    # secret stored for Phase 5 Svix signature verification
+    _webhook_secret = secret
+    logger.warning(
+        "Junction webhook signature verification is not yet implemented. "
+        "All requests to %s/webhooks will be accepted without verification.",
+        prefix,
+    )
+    if tags is None:
+        tags = ["junction"]
+    router = APIRouter(prefix=prefix, tags=list(tags))
+
+    @router.post("/webhooks")
+    async def junction_webhook_handler(request: Request) -> JSONResponse:
+        """Handle incoming Junction webhook events.
+
+        Full implementation with Svix signature verification
+        will be added in Phase 5.
+        """
+        body: dict[str, Any] = await request.json()
+        event_type = body.get("event_type", "unknown")
+        logger.info("Received Junction webhook: %s", event_type)
+        return JSONResponse(content={"status": "ok"}, status_code=200)
+
+    return router
+
+
+def register_webhook_api(
+    app: rx.App,
+    secret: str,
+    prefix: str = "/junction",
+    tags: list[str] | None = None,
+) -> APIRouter:
+    """Register the Junction webhook API on a Reflex app.
+
+    Args:
+        app: The Reflex app to register webhooks on.
+        secret: Svix webhook signing secret.
+        prefix: URL prefix for webhook endpoints.
+        tags: OpenAPI tags.
+
+    Returns:
+        The registered APIRouter.
+    """
+    router = create_webhook_router(prefix=prefix, secret=secret, tags=tags)
+
+    if isinstance(app.api_transformer, FastAPI):
+        app.api_transformer.include_router(router)
+    else:
+        fastapi_app = FastAPI()
+        fastapi_app.include_router(router)
+        app.api_transformer = fastapi_app
+
+    return router

reflex_junction/junction_provider.py

@@ -0,0 +1,375 @@
+"""Core Junction state management and app integration for Reflex."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+import uuid
+from typing import Any, ClassVar
+
+import reflex as rx
+from reflex.event import EventCallback, EventType
+
+logger = logging.getLogger(__name__)
+
+# Environment mapping: string name -> VitalEnvironment enum value
+_ENVIRONMENT_MAP: dict[str, str] = {
+    "sandbox": "sandbox",
+    "production": "production",
+    "sandbox_eu": "sandbox_eu",
+    "production_eu": "production_eu",
+}
+
+
+class MissingApiKeyError(ValueError):
+    """Raised when the Junction API key is not set."""
+
+
+class JunctionState(rx.State):
+    """Core state for Junction health data integration.
+
+    Manages the Junction API client, user mapping, and provider connections.
+    Configuration is stored as ClassVars (process-level singletons).
+    Per-session state tracks the current user's Junction data.
+    """
+
+    # Per-session state vars (serialized by Reflex)
+    junction_user_id: str = ""
+    client_user_id: str = ""
+    connected_sources: list[dict[str, Any]] = []
+    is_initialized: bool = False
+    _link_token: str = ""
+    _link_web_url: str = ""
+
+    # ClassVars — process-level singletons, NOT per-session
+    _api_key: ClassVar[str | None] = None
+    _environment: ClassVar[str] = "sandbox"
+    _client: ClassVar[Any | None] = None  # AsyncVital, typed as Any to avoid import at module level
+    _on_load_events: ClassVar[dict[uuid.UUID, list[EventType[()]]]] = {}
+    _dependent_handlers: ClassVar[dict[int, EventCallback]] = {}
+    _init_wait_timeout_seconds: ClassVar[float] = 1.0
+
+    @classmethod
+    def _set_api_key(cls, api_key: str) -> None:
+        """Set the Junction API key (process-level singleton)."""
+        if not api_key:
+            raise MissingApiKeyError("api_key must be set (and not empty)")
+        cls._api_key = api_key
+
+    @classmethod
+    def _set_environment(cls, environment: str) -> None:
+        """Set the Junction environment."""
+        if environment not in _ENVIRONMENT_MAP:
+            logger.warning(
+                "Unknown environment '%s', defaulting to 'sandbox'. "
+                "Valid options: %s",
+                environment,
+                list(_ENVIRONMENT_MAP.keys()),
+            )
+            environment = "sandbox"
+        cls._environment = environment
+
+    @classmethod
+    def _set_client(cls) -> None:
+        """Initialize the AsyncVital client (lazy, called once)."""
+        from vital.client import AsyncVital
+        from vital.environment import VitalEnvironment
+
+        if cls._api_key is None:
+            raise MissingApiKeyError(
+                "Junction API key not set. Call wrap_app() or junction_provider() first."
+            )
+
+        env_map = {
+            "sandbox": VitalEnvironment.SANDBOX,
+            "production": VitalEnvironment.PRODUCTION,
+            "sandbox_eu": VitalEnvironment.SANDBOX_EU,
+            "production_eu": VitalEnvironment.PRODUCTION_EU,
+        }
+        vital_env = env_map.get(cls._environment, VitalEnvironment.SANDBOX)
+        cls._client = AsyncVital(api_key=cls._api_key, environment=vital_env)
+
+    @property
+    def client(self) -> Any:
+        """Get the AsyncVital client, initializing lazily if needed."""
+        if self._client is None:
+            self._set_client()
+        return self._client
+
+    @classmethod
+    def register_dependent_handler(cls, handler: EventCallback) -> None:
+        """Register a handler to be called after initialization.
+
+        Uses hash-based dedup to prevent double-registration.
+        """
+        if not isinstance(handler, rx.EventHandler):
+            raise TypeError(f"Expected EventHandler, got {type(handler)}")
+        hash_id = hash((handler.state_full_name, handler.fn))
+        cls._dependent_handlers[hash_id] = handler
+
+    @classmethod
+    def _set_on_load_events(
+        cls, uid: uuid.UUID, events: list[EventType[()]]
+    ) -> None:
+        """Store on_load events by UUID for later retrieval."""
+        cls._on_load_events[uid] = events
+
+    @rx.event
+    async def initialize(self) -> list[EventCallback]:
+        """Initialize the Junction state. Sets is_initialized and fires dependent handlers."""
+        self.is_initialized = True
+        return list(self._dependent_handlers.values())
+
+    @rx.event(background=True)
+    async def wait_for_init(self, uid: str) -> list[EventType[()]]:
+        """Wait for Junction state to be initialized, then return stored on_load events.
+
+        Args:
+            uid: String UUID identifying the on_load event batch.
+        """
+        parsed_uid = uuid.UUID(uid) if isinstance(uid, str) else uid
+        on_loads = self._on_load_events.get(parsed_uid, [])
+
+        start = time.monotonic()
+        while time.monotonic() - start < self._init_wait_timeout_seconds:
+            async with self:
+                if self.is_initialized:
+                    return on_loads
+            await asyncio.sleep(0.05)
+
+        logger.warning(
+            "Junction init wait timed out after %.1fs. "
+            "Proceeding with on_load handlers anyway.",
+            self._init_wait_timeout_seconds,
+        )
+        return on_loads
+
+    @rx.event
+    async def create_user(self, client_user_id: str) -> None:
+        """Create a Junction user mapped to the given client user ID.
+
+        Args:
+            client_user_id: Your application's internal user identifier.
+        """
+        result = await self.client.user.create(client_user_id=client_user_id)
+        self.junction_user_id = str(result.user_id)
+        self.client_user_id = client_user_id
+
+    @rx.event
+    async def get_connected_providers(self) -> None:
+        """Fetch and update the list of connected providers for the current user."""
+        if not self.junction_user_id:
+            logger.warning("No junction_user_id set. Call create_user() first.")
+            return
+        result = await self.client.user.get_connected_providers(
+            user_id=self.junction_user_id
+        )
+        # Flatten the provider status dict into a list of dicts
+        providers = []
+        for source_type, source_list in result.items():
+            for source in source_list:
+                providers.append(
+                    {
+                        "source_type": source_type,
+                        "name": getattr(source, "name", ""),
+                        "slug": getattr(source, "slug", ""),
+                        "logo": getattr(source, "logo", ""),
+                        "status": getattr(source, "status", ""),
+                    }
+                )
+        self.connected_sources = providers
+
+    @rx.event
+    async def disconnect_provider(self, provider: str) -> EventCallback | None:
+        """Disconnect a specific provider for the current user.
+
+        Args:
+            provider: The provider slug to disconnect (e.g., 'oura').
+        """
+        if not self.junction_user_id:
+            logger.warning("No junction_user_id set. Call create_user() first.")
+            return
+        await self.client.user.deregister_provider(
+            user_id=self.junction_user_id,
+            provider=provider,
+        )
+        # Refresh the connected sources list
+        return JunctionState.get_connected_providers  # type: ignore[return-value]
+
+    @rx.event
+    async def refresh_data(self) -> None:
+        """Trigger a data refresh for the current user from all connected providers."""
+        if not self.junction_user_id:
+            logger.warning("No junction_user_id set. Call create_user() first.")
+            return
+        await self.client.user.refresh(user_id=self.junction_user_id)
+
+    @rx.event
+    async def create_link_token(self, redirect_url: str = "") -> None:
+        """Generate a Junction Link token for the current user.
+
+        The token and web URL are stored in state for use by the Link widget.
+
+        Args:
+            redirect_url: URL to redirect to after provider connection.
+        """
+        if not self.junction_user_id:
+            logger.warning("No junction_user_id set. Call create_user() first.")
+            return
+        kwargs: dict[str, Any] = {"user_id": self.junction_user_id}
+        if redirect_url:
+            kwargs["redirect_url"] = redirect_url
+        result = await self.client.link.token(**kwargs)
+        self._link_token = str(result.link_token)
+        self._link_web_url = str(result.link_web_url)
+
+    @rx.var
+    def has_connections(self) -> bool:
+        """Whether the current user has any connected providers."""
+        return len(self.connected_sources) > 0
+
+    @rx.var
+    def provider_slugs(self) -> list[str]:
+        """List of connected provider slugs."""
+        return [p.get("slug", "") for p in self.connected_sources]
+
+    @rx.var
+    def link_token(self) -> str:
+        """The current link token for the Link widget."""
+        return self._link_token
+
+    @rx.var
+    def link_web_url(self) -> str:
+        """The current link web URL for redirect-based flow."""
+        return self._link_web_url
+
+
+class JunctionUser(JunctionState):
+    """Extended Junction state with health data summaries.
+
+    Inherits from JunctionState and adds per-user health data fields.
+    Register via register_on_auth_change_handler(JunctionUser.load_user).
+    """
+
+    activity_summary: list[dict[str, Any]] = []
+    sleep_summary: list[dict[str, Any]] = []
+    body_summary: list[dict[str, Any]] = []
+    profile: dict[str, Any] = {}
+    meal_summary: list[dict[str, Any]] = []
+    workout_summary: list[dict[str, Any]] = []
+
+    @rx.event
+    async def load_user(self) -> None:
+        """Load the current user's connected providers and profile.
+
+        This is typically registered as a dependent handler via
+        register_on_auth_change_handler(JunctionUser.load_user).
+        """
+        if not self.junction_user_id:
+            return
+        try:
+            await self.get_connected_providers()
+        except Exception:
+            logger.exception("Failed to load connected providers")
+
+
+def junction_provider(
+    *children: rx.Component,
+    api_key: str,
+    environment: str = "sandbox",
+    register_user_state: bool = False,
+) -> rx.Component:
+    """Configure Junction integration and return a component wrapping children.
+
+    Args:
+        *children: Child components to wrap.
+        api_key: Junction API key.
+        environment: Junction environment (sandbox, production, sandbox_eu, production_eu).
+        register_user_state: If True, registers JunctionUser.load_user as a dependent handler.
+
+    Returns:
+        A Reflex component wrapping the children with Junction configuration.
+    """
+    JunctionState._set_api_key(api_key)
+    JunctionState._set_environment(environment)
+
+    if register_user_state:
+        register_on_auth_change_handler(JunctionUser.load_user)
+
+    # In Phase 1, we just return children wrapped in a fragment.
+    # Phase 2 will add the actual JunctionLinkProvider React component.
+    return rx.fragment(*children)
+
+
+def wrap_app(
+    app: rx.App,
+    api_key: str,
+    environment: str = "sandbox",
+    register_user_state: bool = False,
+    register_webhooks: bool = False,
+    webhook_secret: str | None = None,
+    webhook_prefix: str = "/junction",
+) -> rx.App:
+    """Wrap a Reflex app with Junction health data integration.
+
+    Args:
+        app: The Reflex app to wrap.
+        api_key: Junction API key.
+        environment: Junction environment (sandbox, production, sandbox_eu, production_eu).
+        register_user_state: If True, registers JunctionUser.load_user as dependent handler.
+        register_webhooks: If True, registers the webhook API endpoint.
+        webhook_secret: Svix webhook secret for signature verification.
+        webhook_prefix: URL prefix for the webhook endpoint.
+
+    Returns:
+        The wrapped Reflex app.
+    """
+    # Priority 1 makes this the first wrapper around the content
+    app.app_wraps[(1, "JunctionProvider")] = lambda _: junction_provider(
+        api_key=api_key,
+        environment=environment,
+        register_user_state=register_user_state,
+    )
+
+    if register_webhooks:
+        if not webhook_secret:
+            raise ValueError(
+                "webhook_secret is required when register_webhooks=True"
+            )
+        from .fastapi_helpers import register_webhook_api
+
+        register_webhook_api(app, secret=webhook_secret, prefix=webhook_prefix)
+
+    return app
+
+
+def on_load(
+    on_load_list: list[EventType[()]],
+) -> list[EventType[()]]:
+    """Wrap on_load handlers to ensure Junction state is initialized first.
+
+    Usage:
+        app.add_page(
+            my_page,
+            on_load=[*junction.on_load([MyState.load_data]), ...],
+        )
+
+    Args:
+        on_load_list: List of event handlers to run after Junction initializes.
+
+    Returns:
+        A list containing the wait_for_init event handler.
+    """
+    uid = uuid.uuid4()
+    JunctionState._set_on_load_events(uid, on_load_list)
+    return [JunctionState.wait_for_init(str(uid))]  # type: ignore[list-item]
+
+
+def register_on_auth_change_handler(handler: EventCallback) -> None:
+    """Register an event handler to be called after Junction initialization.
+
+    Args:
+        handler: An rx.EventHandler to call after initialization.
+    """
+    JunctionState.register_dependent_handler(handler)

reflex_junction/models.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from reflex.components.props import PropsBase
+
+
+class JunctionConfig(PropsBase):
+    """Configuration for the Junction health data integration."""
+
+    environment: str = "sandbox"
+    """The Junction environment. One of: sandbox, production, sandbox_eu, production_eu."""
+
+    region: str = "us"
+    """The region for data storage. One of: us, eu."""
+
+
+class LinkConfig(PropsBase):
+    """Configuration for the Junction Link widget."""
+
+    redirect_url: str = ""
+    """URL to redirect to after a successful provider connection."""
+
+    filter_on_providers: list[str] | None = None
+    """Optional list of provider slugs to show in the Link widget."""
+
+
+class ProviderInfo(PropsBase):
+    """Information about a connected health data provider."""
+
+    name: str = ""
+    """The display name of the provider (e.g., 'Oura')."""
+
+    slug: str = ""
+    """The provider slug identifier (e.g., 'oura')."""
+
+    logo: str = ""
+    """URL to the provider's logo image."""
+
+    auth_type: str = ""
+    """The authentication type: oauth, password, email, sdk."""

reflex_junction-0.1.0.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: reflex-junction
+Version: 0.1.0
+Summary: Reflex custom component wrapping @tryvital/vital-link and integrating the Junction (Vital) health data SDK
+Project-URL: repository, https://github.com/Syntropy-Health/reflex-junction
+Author: Syntropy Health
+License-Expression: MIT
+License-File: LICENSE
+Keywords: health-data,junction,reflex,reflex-custom-components,vital
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: reflex>=0.8.0
+Requires-Dist: vital>=2.1.0
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+[![CI](https://github.com/Syntropy-Health/reflex-junction/actions/workflows/ci.yml/badge.svg)](https://github.com/Syntropy-Health/reflex-junction/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/reflex-junction.svg)](https://pypi.org/project/reflex-junction/)
+[![Python](https://img.shields.io/pypi/pyversions/reflex-junction.svg)](https://pypi.org/project/reflex-junction/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Docs](https://img.shields.io/badge/docs-mkdocs-blue)](https://syntropy-health.github.io/reflex-junction/)
+
+# reflex-junction
+
+A [Reflex](https://reflex.dev) custom component for integrating [Junction (Vital)](https://tryvital.io/) health data into your application. Connect wearables and health platforms (Oura, Fitbit, Apple Health, Garmin, etc.) with a few lines of Python.
+
+## Features
+
+- **JunctionState** — Reflex state management for the Vital API (user creation, provider connections, data refresh)
+- **JunctionUser** — Extended state with health data summaries (activity, sleep, body, meals, workouts)
+- **wrap_app()** — One-line integration that configures your entire Reflex app
+- **junction_provider()** — Component-level integration for wrapping specific pages
+- **Webhook support** — FastAPI router for receiving real-time health data events
+- **Link widget support** — Token generation for the Vital Link provider connection UI
+- **Multi-region** — US and EU sandbox/production environments
+
+## Installation
+
+```bash
+pip install reflex-junction
+```
+
+Or with your preferred package manager:
+
+```bash
+uv add reflex-junction
+poetry add reflex-junction
+```
+
+## Quick Start
+
+### 1. Get an API key
+
+Sign up at [tryvital.io](https://tryvital.io/) and grab your API key from the dashboard.
+
+### 2. Wrap your app
+
+```python
+import os
+import reflex as rx
+import reflex_junction as junction
+
+app = rx.App()
+
+junction.wrap_app(
+    app,
+    api_key=os.environ["JUNCTION_API_KEY"],
+    environment="sandbox",  # or "production"
+    register_user_state=True,
+)
+```
+
+### 3. Use Junction state in your pages
+
+```python
+def health_dashboard() -> rx.Component:
+    return rx.container(
+        rx.heading("Health Dashboard"),
+        rx.text(f"Connected: {junction.JunctionState.has_connections}"),
+        rx.foreach(
+            junction.JunctionState.connected_sources,
+            lambda p: rx.badge(p["name"]),
+        ),
+    )
+```
+
+## Usage
+
+### Using `junction_provider` directly
+
+For page-level integration instead of app-wide:
+
+```python
+import reflex_junction as junction
+
+def health_page() -> rx.Component:
+    return junction.junction_provider(
+        rx.container(
+            rx.text("Connected providers: "),
+            rx.text(junction.JunctionState.connected_sources.length()),
+        ),
+        api_key=os.environ["JUNCTION_API_KEY"],
+    )
+```
+
+### Webhook support
+
+Receive real-time events when health data updates:
+
+```python
+junction.wrap_app(
+    app,
+    api_key=os.environ["JUNCTION_API_KEY"],
+    register_webhooks=True,
+    webhook_secret=os.environ["JUNCTION_WEBHOOK_SECRET"],
+    webhook_prefix="/junction",  # POST /junction/webhooks
+)
+```
+
+### Environment options
+
+| Environment      | Description        |
+|------------------|--------------------|
+| `sandbox`        | US sandbox (default) |
+| `production`     | US production      |
+| `sandbox_eu`     | EU sandbox         |
+| `production_eu`  | EU production      |
+
+## API Reference
+
+### State Classes
+
+| Class | Description |
+|-------|-------------|
+| `JunctionState` | Core state — user creation, provider management, Link tokens |
+| `JunctionUser` | Extended state — health data summaries (activity, sleep, body, meals, workouts) |
+
+### Configuration Models
+
+| Class | Description |
+|-------|-------------|
+| `JunctionConfig` | Environment and region settings |
+| `LinkConfig` | Redirect URL and provider filter for the Link widget |
+| `ProviderInfo` | Provider metadata (name, slug, logo, auth_type) |
+
+### Functions
+
+| Function | Description |
+|----------|-------------|
+| `wrap_app(app, api_key, ...)` | One-line app integration with optional webhooks |
+| `junction_provider(*children, api_key, ...)` | Component wrapper for page-level integration |
+| `on_load(handlers)` | Wrap page on_load handlers to wait for Junction init |
+| `register_on_auth_change_handler(handler)` | Register handler to fire after Junction initializes |
+| `create_webhook_router(prefix, secret)` | Create a standalone FastAPI webhook router |
+| `register_webhook_api(app, secret, prefix)` | Register webhook endpoint on a Reflex app |
+
+### JunctionState Events
+
+| Event | Description |
+|-------|-------------|
+| `create_user(client_user_id)` | Create a Junction user mapped to your app's user |
+| `get_connected_providers()` | Fetch connected health data providers |
+| `disconnect_provider(provider)` | Disconnect a specific provider by slug |
+| `refresh_data()` | Trigger data sync from all connected providers |
+| `create_link_token(redirect_url)` | Generate a Link widget token |
+
+See the [full documentation](https://syntropy-health.github.io/reflex-junction/) for detailed guides.
+
+## Contributing
+
+Contributions welcome! We use [Taskfile](https://taskfile.dev/) for common tasks:
+
+```bash
+task install          # Install dev dependencies + pre-commit
+task test             # Run lint + typecheck + pytest
+task run              # Run the demo app
+task run-docs         # Serve docs locally at localhost:9000
+task bump-patch       # Bump patch version (bug fix)
+task bump-minor       # Bump minor version (new feature)
+```
+
+Workflow: Fork → feature branch → add tests → submit PR.
+
+## License
+
+[MIT](LICENSE) — Copyright (c) 2025 Syntropy Health

reflex_junction-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+reflex_junction/__init__.py,sha256=pcLZuRStSv7DCMJkfHirWj94vZBLzgs8opow7lkkeeM,614
+reflex_junction/base.py,sha256=QgfMP_G01Jd0QlJDYcfcS51h-UxuucnmZJ6NpXAdDp8,157
+reflex_junction/fastapi_helpers.py,sha256=6XgyLIJvg4vdssarOAlwQ451OJTO3HzGa6Pmq048xps,2447
+reflex_junction/junction_provider.py,sha256=nxiQ5W8hag3xPpuR3N1ng0IL_JWnh48xqIZV245ooF0,13342
+reflex_junction/models.py,sha256=wK-fIsJB0b9YC7Sz_WF38eX9fMYAB5G5GV1-R-ai6qY,1092
+reflex_junction-0.1.0.dist-info/METADATA,sha256=_Y9VHcJD8dcw1kj2SwfdTHyLEDsWaGPfubYLNrXTPuk,6604
+reflex_junction-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+reflex_junction-0.1.0.dist-info/licenses/LICENSE,sha256=Q33wpujwLLO_70ggNjdv3OoBE6qsiyJNuHHXIICpTFY,1072
+reflex_junction-0.1.0.dist-info/RECORD,,

reflex_junction-0.1.0.dist-info/WHEEL

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

reflex_junction-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Syntropy Health
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.