pyview-web 0.2.5__py3-none-any.whl → 0.3.0__py3-none-any.whl

pyview/csrf.py

@@ -1,8 +1,11 @@
 from itsdangerous import BadData, SignatureExpired, URLSafeTimedSerializer
 from typing import Optional
 import hmac
+import logging
 from pyview.secret import get_secret
 
+logger = logging.getLogger(__name__)
+
 
 def generate_csrf_token(value: str, salt: Optional[str] = None) -> str:
     """
@@ -20,6 +23,6 @@ def validate_csrf_token(data: str, expected: str, salt: Optional[str] = None) ->
     try:
         token = s.loads(data, max_age=3600)
         return hmac.compare_digest(token, expected)
-    except (BadData, SignatureExpired) as e:
-        print(e)
+    except (BadData, SignatureExpired):
+        logger.debug("CSRF token validation failed", exc_info=True)
         return False

pyview/events/BaseEventHandler.py

@@ -55,10 +55,10 @@ class BaseEventHandler:
         else:
             logging.warning(f"Unhandled event: {event} {payload}")
 
-    async def handle_info(self, info: "InfoEvent", socket):
-        handler = self._info_handlers.get(info.name)
+    async def handle_info(self, event: "InfoEvent", socket):
+        handler = self._info_handlers.get(event.name)
 
         if handler:
-            return await handler(self, info, socket)
+            return await handler(self, event, socket)
         else:
-            logging.warning(f"Unhandled info: {info.name} {info}")
+            logging.warning(f"Unhandled info: {event.name} {event}")

pyview/instrumentation/__init__.py

@@ -0,0 +1,21 @@
+"""PyView instrumentation interfaces and implementations."""
+
+from .interfaces import (
+    InstrumentationProvider,
+    Counter,
+    UpDownCounter,
+    Gauge,
+    Histogram,
+    Span,
+)
+from .noop import NoOpInstrumentation
+
+__all__ = [
+    "InstrumentationProvider",
+    "Counter",
+    "UpDownCounter",
+    "Gauge",
+    "Histogram",
+    "Span",
+    "NoOpInstrumentation",
+]

pyview/instrumentation/interfaces.py

@@ -0,0 +1,182 @@
+"""Abstract base classes for PyView instrumentation."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Callable, Union
+from contextlib import contextmanager
+import functools
+import time
+import asyncio
+
+
+class Counter(ABC):
+    """A monotonically increasing counter metric."""
+    
+    @abstractmethod
+    def add(self, value: float = 1, attributes: Optional[dict[str, Any]] = None) -> None:
+        """Add to the counter value."""
+        pass
+
+
+class UpDownCounter(ABC):
+    """A counter that can increase or decrease."""
+    
+    @abstractmethod
+    def add(self, value: float, attributes: Optional[dict[str, Any]] = None) -> None:
+        """Add to the counter value (can be negative)."""
+        pass
+
+
+class Gauge(ABC):
+    """A point-in-time value metric."""
+    
+    @abstractmethod
+    def set(self, value: float, attributes: Optional[dict[str, Any]] = None) -> None:
+        """Set the gauge to a specific value."""
+        pass
+
+
+class Histogram(ABC):
+    """A metric that tracks the distribution of values."""
+    
+    @abstractmethod
+    def record(self, value: float, attributes: Optional[dict[str, Any]] = None) -> None:
+        """Record a value in the histogram."""
+        pass
+
+
+class Span(ABC):
+    """A span representing a unit of work."""
+    
+    @abstractmethod
+    def set_attribute(self, key: str, value: Any) -> None:
+        """Set an attribute on the span."""
+        pass
+    
+    @abstractmethod
+    def add_event(self, name: str, attributes: Optional[dict[str, Any]] = None) -> None:
+        """Add an event to the span."""
+        pass
+    
+    @abstractmethod
+    def end(self, status: str = "ok") -> None:
+        """End the span with a status."""
+        pass
+
+
+class InstrumentationProvider(ABC):
+    """Abstract base class for instrumentation providers."""
+    
+    # Create instruments (efficient, reusable)
+    @abstractmethod
+    def create_counter(self, name: str, description: str = "", unit: str = "") -> Counter:
+        """Create a counter instrument."""
+        pass
+    
+    @abstractmethod
+    def create_updown_counter(self, name: str, description: str = "", unit: str = "") -> UpDownCounter:
+        """Create an up/down counter instrument."""
+        pass
+    
+    @abstractmethod
+    def create_gauge(self, name: str, description: str = "", unit: str = "") -> Gauge:
+        """Create a gauge instrument."""
+        pass
+    
+    @abstractmethod
+    def create_histogram(self, name: str, description: str = "", unit: str = "") -> Histogram:
+        """Create a histogram instrument."""
+        pass
+    
+    # Convenience methods (simple, pass name each time)
+    def increment_counter(self, name: str, value: float = 1, attributes: Optional[dict[str, Any]] = None) -> None:
+        """Convenience method to increment a counter."""
+        counter = self.create_counter(name)
+        counter.add(value, attributes)
+    
+    def update_updown_counter(self, name: str, value: float, attributes: Optional[dict[str, Any]] = None) -> None:
+        """Convenience method to update an up/down counter."""
+        counter = self.create_updown_counter(name)
+        counter.add(value, attributes)
+    
+    def record_gauge(self, name: str, value: float, attributes: Optional[dict[str, Any]] = None) -> None:
+        """Convenience method to record a gauge value."""
+        gauge = self.create_gauge(name)
+        gauge.set(value, attributes)
+    
+    def record_histogram(self, name: str, value: float, attributes: Optional[dict[str, Any]] = None) -> None:
+        """Convenience method to record a histogram value."""
+        histogram = self.create_histogram(name)
+        histogram.record(value, attributes)
+    
+    # Span methods
+    @abstractmethod
+    def start_span(self, name: str, attributes: Optional[dict[str, Any]] = None) -> Span:
+        """Start a new span."""
+        pass
+    
+    # Context manager for spans
+    @contextmanager
+    def span(self, name: str, attributes: Optional[dict[str, Any]] = None):
+        """Context manager for creating and managing spans."""
+        span = self.start_span(name, attributes)
+        try:
+            yield span
+        except Exception as e:
+            span.set_attribute("error", True)
+            span.set_attribute("error.message", str(e))
+            span.set_attribute("error.type", type(e).__name__)
+            span.end("error")
+            raise
+        else:
+            span.end("ok")
+    
+    # Decorator for tracing functions
+    def trace(self, name: Optional[str] = None, attributes: Optional[dict[str, Any]] = None):
+        """Decorator to trace function execution."""
+        def decorator(func: Callable):
+            span_name = name or f"{func.__module__}.{func.__name__}"
+            
+            if asyncio.iscoroutinefunction(func):
+                @functools.wraps(func)
+                async def async_wrapper(*args, **kwargs):
+                    with self.span(span_name, attributes):
+                        return await func(*args, **kwargs)
+                return async_wrapper
+            else:
+                @functools.wraps(func)
+                def sync_wrapper(*args, **kwargs):
+                    with self.span(span_name, attributes):
+                        return func(*args, **kwargs)
+                return sync_wrapper
+        return decorator
+    
+    # Timing helpers
+    @contextmanager
+    def time_histogram(self, name: str, attributes: Optional[dict[str, Any]] = None):
+        """Context manager to time operations and record to histogram."""
+        histogram = self.create_histogram(name, unit="s")
+        start = time.perf_counter()
+        try:
+            yield
+        finally:
+            duration = time.perf_counter() - start
+            histogram.record(duration, attributes)
+    
+    def time_function(self, histogram_name: Optional[str] = None, attributes: Optional[dict[str, Any]] = None):
+        """Decorator to time function execution."""
+        def decorator(func: Callable):
+            name = histogram_name or f"{func.__module__}.{func.__name__}.duration"
+            
+            if asyncio.iscoroutinefunction(func):
+                @functools.wraps(func)
+                async def async_wrapper(*args, **kwargs):
+                    with self.time_histogram(name, attributes):
+                        return await func(*args, **kwargs)
+                return async_wrapper
+            else:
+                @functools.wraps(func)
+                def sync_wrapper(*args, **kwargs):
+                    with self.time_histogram(name, attributes):
+                        return func(*args, **kwargs)
+                return sync_wrapper
+        return decorator

pyview/instrumentation/noop.py

@@ -0,0 +1,97 @@
+"""No-operation implementation of instrumentation interfaces."""
+
+from typing import Any, Optional
+from .interfaces import (
+    InstrumentationProvider,
+    Counter,
+    UpDownCounter,
+    Gauge,
+    Histogram,
+    Span,
+)
+
+
+class NoOpCounter(Counter):
+    """No-op counter implementation."""
+    
+    def add(self, value: float = 1, attributes: Optional[dict[str, Any]] = None) -> None:
+        """No-op: does nothing."""
+        pass
+
+
+class NoOpUpDownCounter(UpDownCounter):
+    """No-op up/down counter implementation."""
+    
+    def add(self, value: float, attributes: Optional[dict[str, Any]] = None) -> None:
+        """No-op: does nothing."""
+        pass
+
+
+class NoOpGauge(Gauge):
+    """No-op gauge implementation."""
+    
+    def set(self, value: float, attributes: Optional[dict[str, Any]] = None) -> None:
+        """No-op: does nothing."""
+        pass
+
+
+class NoOpHistogram(Histogram):
+    """No-op histogram implementation."""
+    
+    def record(self, value: float, attributes: Optional[dict[str, Any]] = None) -> None:
+        """No-op: does nothing."""
+        pass
+
+
+class NoOpSpan(Span):
+    """No-op span implementation."""
+    
+    def set_attribute(self, key: str, value: Any) -> None:
+        """No-op: does nothing."""
+        pass
+    
+    def add_event(self, name: str, attributes: Optional[dict[str, Any]] = None) -> None:
+        """No-op: does nothing."""
+        pass
+    
+    def end(self, status: str = "ok") -> None:
+        """No-op: does nothing."""
+        pass
+
+
+class NoOpInstrumentation(InstrumentationProvider):
+    """
+    Default no-operation instrumentation provider.
+    
+    This implementation does nothing and has zero performance overhead.
+    It's used as the default when no instrumentation is configured.
+    """
+    
+    def __init__(self):
+        """Initialize the no-op provider."""
+        # Cache single instances to avoid object creation overhead
+        self._counter = NoOpCounter()
+        self._updown_counter = NoOpUpDownCounter()
+        self._gauge = NoOpGauge()
+        self._histogram = NoOpHistogram()
+        self._span = NoOpSpan()
+    
+    def create_counter(self, name: str, description: str = "", unit: str = "") -> Counter:
+        """Return a no-op counter."""
+        return self._counter
+    
+    def create_updown_counter(self, name: str, description: str = "", unit: str = "") -> UpDownCounter:
+        """Return a no-op up/down counter."""
+        return self._updown_counter
+    
+    def create_gauge(self, name: str, description: str = "", unit: str = "") -> Gauge:
+        """Return a no-op gauge."""
+        return self._gauge
+    
+    def create_histogram(self, name: str, description: str = "", unit: str = "") -> Histogram:
+        """Return a no-op histogram."""
+        return self._histogram
+    
+    def start_span(self, name: str, attributes: Optional[dict[str, Any]] = None) -> Span:
+        """Return a no-op span."""
+        return self._span

pyview/live_socket.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 from starlette.websockets import WebSocket
 import json
+import logging
 from typing import (
     Any,
     TypeVar,
@@ -13,6 +14,7 @@ from typing import (
 )
 from urllib.parse import urlencode
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.jobstores.base import JobLookupError
 from pyview.vendor.flet.pubsub import PubSubHub, PubSub
 from pyview.events import InfoEvent
 from pyview.uploads import UploadConstraints, UploadConfig, UploadManager
@@ -21,12 +23,13 @@ from pyview.template.render_diff import calc_diff
 import datetime
 from pyview.async_stream_runner import AsyncStreamRunner
 
+logger = logging.getLogger(__name__)
+
 
 if TYPE_CHECKING:
     from .live_view import LiveView
+    from .instrumentation import InstrumentationProvider
 
-scheduler = AsyncIOScheduler()
-scheduler.start()
 
 pub_sub_hub = PubSubHub()
 
@@ -55,16 +58,25 @@ class ConnectedLiveViewSocket(Generic[T]):
     upload_manager: UploadManager
     prev_rendered: Optional[dict[str, Any]] = None
 
-    def __init__(self, websocket: WebSocket, topic: str, liveview: LiveView):
+    def __init__(
+        self,
+        websocket: WebSocket,
+        topic: str,
+        liveview: LiveView,
+        scheduler: AsyncIOScheduler,
+        instrumentation: "InstrumentationProvider",
+    ):
         self.websocket = websocket
         self.topic = topic
         self.liveview = liveview
+        self.instrumentation = instrumentation
         self.scheduled_jobs = []
         self.connected = True
         self.pub_sub = PubSub(pub_sub_hub, topic)
         self.pending_events = []
         self.upload_manager = UploadManager()
         self.stream_runner = AsyncStreamRunner(self)
+        self.scheduler = scheduler
 
     @property
     def meta(self) -> PyViewMeta:
@@ -81,13 +93,13 @@ class ConnectedLiveViewSocket(Generic[T]):
 
     def schedule_info(self, event, seconds):
         id = f"{self.topic}:{event}"
-        scheduler.add_job(
+        self.scheduler.add_job(
             self.send_info, args=[event], id=id, trigger="interval", seconds=seconds
         )
         self.scheduled_jobs.append(id)
 
     def schedule_info_once(self, event, seconds=None):
-        scheduler.add_job(
+        self.scheduler.add_job(
             self.send_info,
             args=[event],
             trigger="date",
@@ -113,8 +125,13 @@ class ConnectedLiveViewSocket(Generic[T]):
             await self.websocket.send_text(json.dumps(resp))
         except Exception:
             for id in self.scheduled_jobs:
-                print("Removing job", id)
-                scheduler.remove_job(id)
+                logger.debug("Removing scheduled job %s", id)
+                try:
+                    self.scheduler.remove_job(id)
+                except Exception:
+                    logger.warning(
+                        "Failed to remove scheduled job %s", id, exc_info=True
+                    )
 
     async def push_patch(self, path: str, params: dict[str, Any] = {}):
         # or "replace"
@@ -142,8 +159,38 @@ class ConnectedLiveViewSocket(Generic[T]):
         await self.liveview.handle_params(to, params, self)
         try:
             await self.websocket.send_text(json.dumps(message))
-        except Exception as e:
-            print("Error sending message", e)
+        except Exception:
+            logger.warning("Error sending patch message", exc_info=True)
+
+    async def push_navigate(self, path: str, params: dict[str, Any] = {}):
+        """Navigate to a different LiveView without full page reload"""
+        await self._navigate(path, params, kind="push")
+
+    async def replace_navigate(self, path: str, params: dict[str, Any] = {}):
+        """Navigate to a different LiveView, replacing current history entry"""
+        await self._navigate(path, params, kind="replace")
+
+    async def _navigate(self, path: str, params: dict[str, Any], kind: str):
+        """Internal navigation helper"""
+        to = path
+        if params:
+            to = to + "?" + urlencode(params)
+
+        message = [
+            None,
+            None,
+            self.topic,
+            "live_redirect",
+            {
+                "kind": kind,
+                "to": to,
+            },
+        ]
+
+        try:
+            await self.websocket.send_text(json.dumps(message))
+        except Exception:
+            logger.warning("Error sending navigation message", exc_info=True)
 
     async def push_event(self, event: str, value: dict[str, Any]):
         self.pending_events.append((event, value))
@@ -156,7 +203,10 @@ class ConnectedLiveViewSocket(Generic[T]):
     async def close(self):
         self.connected = False
         for id in self.scheduled_jobs:
-            scheduler.remove_job(id)
+            try:
+                self.scheduler.remove_job(id)
+            except JobLookupError:
+                pass
         await self.pub_sub.unsubscribe_all_async()
 
         try:

pyview/pyview.py

@@ -5,12 +5,14 @@ from starlette.routing import Route, WebSocketRoute
 from starlette.requests import Request
 import uuid
 from urllib.parse import parse_qs, urlparse
+from typing import Optional
 
 from pyview.live_socket import UnconnectedSocket
 from pyview.csrf import generate_csrf_token
 from pyview.session import serialize_session
 from pyview.auth import AuthProviderFactory
 from pyview.meta import PyViewMeta
+from pyview.instrumentation import InstrumentationProvider, NoOpInstrumentation
 from .ws_handler import LiveSocketHandler
 from .live_view import LiveView
 from .live_routes import LiveViewLookup
@@ -24,12 +26,14 @@ from .template import (
 
 class PyView(Starlette):
     rootTemplate: RootTemplate
+    instrumentation: InstrumentationProvider
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, instrumentation: Optional[InstrumentationProvider] = None, **kwargs):
         super().__init__(*args, **kwargs)
         self.rootTemplate = defaultRootTemplate()
+        self.instrumentation = instrumentation or NoOpInstrumentation()
         self.view_lookup = LiveViewLookup()
-        self.live_handler = LiveSocketHandler(self.view_lookup)
+        self.live_handler = LiveSocketHandler(self.view_lookup, self.instrumentation)
 
         self.routes.append(WebSocketRoute("/live/websocket", self.live_handler.handle))
         self.add_middleware(GZipMiddleware)

pyview/uploads.py

@@ -1,5 +1,6 @@
 import datetime
 import uuid
+import logging
 from pydantic import BaseModel, Field
 from typing import Optional, Any, Literal, Generator
 from dataclasses import dataclass, field
@@ -7,6 +8,8 @@ from contextlib import contextmanager
 import os
 import tempfile
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class ConstraintViolation:
@@ -143,8 +146,8 @@ class UploadConfig(BaseModel):
         finally:
             try:
                 self.uploads.close()
-            except Exception as e:
-                print("Error closing uploads", e)
+            except Exception:
+                logger.warning("Error closing uploads", exc_info=True)
 
             self.uploads = ActiveUploads()
             self.entries_by_ref = {}
@@ -185,14 +188,14 @@ class UploadManager:
                     entries = uploads[config.ref]
                     config.add_entries(entries)
                 else:
-                    print("can't find ref", config.ref)
+                    logger.warning("Upload config not found for ref: %s", config.ref)
 
     def process_allow_upload(self, payload: dict[str, Any]) -> dict[str, Any]:
         ref = payload["ref"]
         config = self.config_for_ref(ref)
 
         if not config:
-            print("Can't find config for ref", ref)
+            logger.warning("Can't find upload config for ref: %s", ref)
             return {"error": [(ref, "not_found")]}
 
         proposed_entries = payload["entries"]

pyview/ws_handler.py

@@ -1,5 +1,6 @@
 from typing import Optional
 import json
+import logging
 from starlette.websockets import WebSocket, WebSocketDisconnect
 from urllib.parse import urlparse, parse_qs
 from pyview.live_socket import ConnectedLiveViewSocket, LiveViewSocket
@@ -8,17 +9,58 @@ from pyview.csrf import validate_csrf_token
 from pyview.session import deserialize_session
 from pyview.auth import AuthProviderFactory
 from pyview.phx_message import parse_message
+from pyview.instrumentation import InstrumentationProvider
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+logger = logging.getLogger(__name__)
 
 
 class AuthException(Exception):
     pass
 
 
+class LiveSocketMetrics:
+    """Container for LiveSocket instrumentation metrics."""
+    
+    def __init__(self, instrumentation: InstrumentationProvider):
+        self.active_connections = instrumentation.create_updown_counter(
+            "pyview.websocket.active_connections",
+            "Number of active WebSocket connections"
+        )
+        self.mounts = instrumentation.create_counter(
+            "pyview.liveview.mounts",
+            "Total number of LiveView mounts"
+        )
+        self.events_processed = instrumentation.create_counter(
+            "pyview.events.processed",
+            "Total number of events processed"
+        )
+        self.event_duration = instrumentation.create_histogram(
+            "pyview.events.duration",
+            "Event processing duration",
+            unit="s"
+        )
+        self.message_size = instrumentation.create_histogram(
+            "pyview.websocket.message_size",
+            "WebSocket message size in bytes",
+            unit="bytes"
+        )
+        self.render_duration = instrumentation.create_histogram(
+            "pyview.render.duration",
+            "Template render duration",
+            unit="s"
+        )
+
+
 class LiveSocketHandler:
-    def __init__(self, routes: LiveViewLookup):
+    def __init__(self, routes: LiveViewLookup, instrumentation: InstrumentationProvider):
         self.routes = routes
+        self.instrumentation = instrumentation
+        self.metrics = LiveSocketMetrics(instrumentation)
         self.manager = ConnectionManager()
         self.sessions = 0
+        self.scheduler = AsyncIOScheduler()
+        self.scheduler.start()
 
     async def check_auth(self, websocket: WebSocket, lv):
         if not await AuthProviderFactory.get(lv).has_required_auth(websocket):
@@ -26,7 +68,9 @@ class LiveSocketHandler:
 
     async def handle(self, websocket: WebSocket):
         await self.manager.connect(websocket)
-
+        
+        # Track active connections
+        self.metrics.active_connections.add(1)
         self.sessions += 1
         topic = None
         socket: Optional[LiveViewSocket] = None
@@ -43,12 +87,16 @@ class LiveSocketHandler:
                 url = urlparse(payload["url"])
                 lv, path_params = self.routes.get(url.path)
                 await self.check_auth(websocket, lv)
-                socket = ConnectedLiveViewSocket(websocket, topic, lv)
+                socket = ConnectedLiveViewSocket(websocket, topic, lv, self.scheduler, self.instrumentation)
 
                 session = {}
                 if "session" in payload:
                     session = deserialize_session(payload["session"])
 
+                # Track mount
+                view_name = lv.__class__.__name__
+                self.metrics.mounts.add(1, {"view": view_name})
+                
                 await lv.mount(socket, session)
 
                 # Parse query parameters and merge with path parameters
@@ -76,9 +124,16 @@ class LiveSocketHandler:
             if socket:
                 await socket.close()
             self.sessions -= 1
+            self.metrics.active_connections.add(-1)
         except AuthException:
             await websocket.close()
             self.sessions -= 1
+            self.metrics.active_connections.add(-1)
+        except Exception:
+            logger.exception("Unexpected error in WebSocket handler")
+            self.sessions -= 1
+            self.metrics.active_connections.add(-1)
+            raise
 
     async def handle_connected(self, myJoinId, socket: ConnectedLiveViewSocket):
         while True:
@@ -105,8 +160,19 @@ class LiveSocketHandler:
                     value = parse_qs(value)
                     socket.upload_manager.maybe_process_uploads(value, payload)
 
-                await socket.liveview.handle_event(payload["event"], value, socket)
-                rendered = await _render(socket)
+                # Track event metrics
+                event_name = payload["event"]
+                view_name = socket.liveview.__class__.__name__
+                self.metrics.events_processed.add(1, {"event": event_name, "view": view_name})
+                
+                # Time event processing
+                with self.instrumentation.time_histogram("pyview.events.duration", 
+                                                         {"event": event_name, "view": view_name}):
+                    await socket.liveview.handle_event(event_name, value, socket)
+                
+                # Time rendering
+                with self.instrumentation.time_histogram("pyview.render.duration", {"view": view_name}):
+                    rendered = await _render(socket)
 
                 hook_events = (
                     {} if not socket.pending_events else {"e": socket.pending_events}
@@ -123,9 +189,9 @@ class LiveSocketHandler:
                     "phx_reply",
                     {"response": {"diff": diff | hook_events}, "status": "ok"},
                 ]
-                await self.manager.send_personal_message(
-                    json.dumps(resp), socket.websocket
-                )
+                resp_json = json.dumps(resp)
+                self.metrics.message_size.record(len(resp_json))
+                await self.manager.send_personal_message(resp_json, socket.websocket)
                 continue
 
             if event == "live_patch":
@@ -185,21 +251,64 @@ class LiveSocketHandler:
                 )
                 continue
 
-            # file upload
+            # file upload or navigation
             if event == "phx_join":
-                socket.upload_manager.add_upload(joinRef, payload)
+                # Check if this is a file upload join (topic starts with "lvu:")
+                if topic.startswith("lvu:"):
+                    # This is a file upload join
+                    socket.upload_manager.add_upload(joinRef, payload)
+
+                    resp = [
+                        joinRef,
+                        mesageRef,
+                        topic,
+                        "phx_reply",
+                        {"response": {}, "status": "ok"},
+                    ]
 
-                resp = [
-                    joinRef,
-                    mesageRef,
-                    topic,
-                    "phx_reply",
-                    {"response": {}, "status": "ok"},
-                ]
+                    await self.manager.send_personal_message(
+                        json.dumps(resp), socket.websocket
+                    )
+                else:
+                    # This is a navigation join (topic starts with "lv:")
+                    # Navigation payload has 'redirect' field instead of 'url'
+                    url_str_raw = payload.get("redirect") or payload.get("url")
+                    url_str: str = url_str_raw.decode("utf-8") if isinstance(url_str_raw, bytes) else str(url_str_raw)
+                    url = urlparse(url_str)
+                    lv, path_params = self.routes.get(url.path)
+                    await self.check_auth(socket.websocket, lv)
+
+                    # Create new socket for new LiveView
+                    socket = ConnectedLiveViewSocket(
+                        socket.websocket, topic, lv, self.scheduler, self.instrumentation
+                    )
 
-                await self.manager.send_personal_message(
-                    json.dumps(resp), socket.websocket
-                )
+                    session = {}
+                    if "session" in payload:
+                        session = deserialize_session(payload["session"])
+
+                    await lv.mount(socket, session)
+
+                    # Parse query parameters and merge with path parameters
+                    query_params = parse_qs(url.query)
+                    merged_params = {**query_params, **path_params}
+
+                    await lv.handle_params(url, merged_params, socket)
+
+                    rendered = await _render(socket)
+                    socket.prev_rendered = rendered
+
+                    resp = [
+                        joinRef,
+                        mesageRef,
+                        topic,
+                        "phx_reply",
+                        {"response": {"rendered": rendered}, "status": "ok"},
+                    ]
+
+                    await self.manager.send_personal_message(
+                        json.dumps(resp), socket.websocket
+                    )
 
             if event == "chunk":
                 socket.upload_manager.add_chunk(joinRef, payload)  # type: ignore
@@ -247,6 +356,23 @@ class LiveSocketHandler:
                     json.dumps(resp), socket.websocket
                 )
 
+            if event == "phx_leave":
+                # Handle LiveView navigation - clean up current LiveView
+                await socket.close()
+
+                resp = [
+                    joinRef,
+                    mesageRef,
+                    topic,
+                    "phx_reply",
+                    {"response": {}, "status": "ok"},
+                ]
+                await self.manager.send_personal_message(
+                    json.dumps(resp), socket.websocket
+                )
+                # Continue to wait for next phx_join
+                continue
+
 
 async def _render(socket: ConnectedLiveViewSocket):
     rendered = (await socket.liveview.render(socket.context, socket.meta)).tree()

{pyview_web-0.2.5.dist-info → pyview_web-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyview-web
-Version: 0.2.5
+Version: 0.3.0
 Summary: LiveView in Python
 License: MIT
 Keywords: web,api,LiveView
@@ -29,14 +29,13 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Dist: APScheduler (==3.9.1.post1)
+Requires-Dist: APScheduler (==3.11.0)
 Requires-Dist: click (>=8.1.7,<9.0.0)
-Requires-Dist: itsdangerous (>=2.1.2,<3.0.0)
-Requires-Dist: markupsafe (>=2.1.2,<3.0.0)
-Requires-Dist: psutil (>=5.9.4,<6.0.0)
+Requires-Dist: itsdangerous (>=2.2.0,<3.0.0)
+Requires-Dist: markupsafe (>=3.0.2,<4.0.0)
 Requires-Dist: pydantic (>=2.9.2,<3.0.0)
-Requires-Dist: starlette (==0.40.0)
-Requires-Dist: uvicorn (==0.30.6)
+Requires-Dist: starlette (==0.47.1)
+Requires-Dist: uvicorn (==0.34.3)
 Requires-Dist: wsproto (==1.2.0)
 Project-URL: Homepage, https://pyview.rocks
 Project-URL: Repository, https://github.com/ogrodnek/pyview

{pyview_web-0.2.5.dist-info → pyview_web-0.3.0.dist-info}/RECORD

@@ -12,17 +12,20 @@ pyview/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyview/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyview/cli/commands/create_view.py,sha256=9hrjc1J1sJHyp3Ihi5ls4Mj19OMNeaj6fpIwDFWrdZ8,5694
 pyview/cli/main.py,sha256=OEHqNwl9fqIPTI6qy5sLYndPHMEJ3fA9qsjSUuKzYSE,296
-pyview/csrf.py,sha256=VIURva9EJqXXYGC7engweh3SwDQCnHlhV2zWdcdnFqc,789
-pyview/events/BaseEventHandler.py,sha256=0xcjFFMLMN8Aj6toI31vzeYhRQqaX9rm-G7XGXMvqsE,1923
+pyview/csrf.py,sha256=2AZaTyUPCbLXvsLoxXixbqOtaKqy0UilUWiHNTlEF20,888
+pyview/events/BaseEventHandler.py,sha256=rBE0z_nN6vIZ8TQ9eRfnCnTEcMOaMX7Na7YgtQmSW3s,1928
 pyview/events/__init__.py,sha256=oP0SG4Af4uf0GEa0Y_zHYhR7TcBOcXQlTAsgOSaIcC4,156
 pyview/events/info_event.py,sha256=JOwf3KDodHkmH1MzqTD8sPxs0zbI4t8Ff0rLjwRSe2Y,358
+pyview/instrumentation/__init__.py,sha256=A5MQbofz9yM177bhY3o4HN4migwd0604e_SuP91R76w,375
+pyview/instrumentation/interfaces.py,sha256=AhVDM_vzETWtM-wfOXaM13K2OgdL0H8lu5wh2DQOxas,6664
+pyview/instrumentation/noop.py,sha256=VP8UjiI--A7KWqnSFh7PMG7MqY0Z9ddQjBYVW7iHZa0,2941
 pyview/js.py,sha256=E6HMsUfXQjrcLqYq26ieeYuzTjBeZqfJwwOm3uSR4ME,3498
 pyview/live_routes.py,sha256=IN2Jmy8b1umcfx1R7ZgFXHZNbYDJp_kLIbADtDJknPM,1749
-pyview/live_socket.py,sha256=p1KtX9Exwhgsf0yOp3Eb32zdUOo5hSnYDJrpJuTu3QI,5084
+pyview/live_socket.py,sha256=exzWVlDhmYEgeNQzz7ROhdFrqPrMU1JtFMImL3Uh5ZQ,6755
 pyview/live_view.py,sha256=mwAp7jiABSZCBgYF-GLQCB7zcJ7Wpz9cuC84zjzsp2U,1455
 pyview/meta.py,sha256=01Z-qldB9jrewmIJHQpUqyIhuHodQGgCvpuY9YM5R6c,74
 pyview/phx_message.py,sha256=DUdPfl6tlw9K0FNXJ35ehq03JGgynvwA_JItHQ_dxMQ,2007
-pyview/pyview.py,sha256=UuAeHdmrcmu3q681NR8IVQ1-LcMBnWyT1vIuQdrLlhY,2666
+pyview/pyview.py,sha256=2rj7NMuc6-tml2Wg4PBV7tydFJVa6XUw0pM0voWYg5g,2972
 pyview/secret.py,sha256=HbaNpGAkFs4uxMVAmk9HwE3FIehg7dmwEOlED7C9moM,363
 pyview/session.py,sha256=nC8ExyVwfCgQfx9T-aJGyFhr2C7jsrEY_QFkaXtP28U,432
 pyview/static/assets/app.js,sha256=QoXfdcOCYwVYJftvjsIIVwFye7onaOJMxRpalyYqoMU,200029
@@ -33,8 +36,7 @@ pyview/template/render_diff.py,sha256=1P-OgtcGb0Y-zJ9uUH3bKWX-qQTHBa4jgg73qJD7eg
 pyview/template/root_template.py,sha256=zCUs1bt8R7qynhBE0tTSEYfdkGtbeKNmPhwzRiFNdsI,2031
 pyview/template/serializer.py,sha256=WDZfqJr2LMlf36fUW2CmWc2aREc63553_y_GRP2-qYc,826
 pyview/template/utils.py,sha256=S8593UjUJztUrtC3h1EL9MxQp5uH7rFDTNkv9C6A_xU,642
-pyview/test_csrf.py,sha256=QWTOtfagDMkoYDK_ehYxua34F7-ltPsSeTwQGEOlqHU,684
-pyview/uploads.py,sha256=cFNOlJD5dkA2VccZT_W1bJn_5vYAaphhRJX-RCfEXm8,9598
+pyview/uploads.py,sha256=AMdlp50uMMI5tS5DaQoaSrKVstu-7cGxIxaFWzg943A,9717
 pyview/vendor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyview/vendor/flet/pubsub/__init__.py,sha256=JSPCeKB26b5E-IVHNRvVHrlf_CBGDLCulE9ADrostGs,39
 pyview/vendor/flet/pubsub/pub_sub.py,sha256=gpdruSxKQBqL7_Dtxo4vETm1kM0YH7S299msw2oyUoE,10184
@@ -48,9 +50,9 @@ pyview/vendor/ibis/nodes.py,sha256=TgFt4q5MrVW3gC3PVitrs2LyXKllRveooM7XKydNATk,2
 pyview/vendor/ibis/template.py,sha256=6XJXnztw87CrOaKeW3e18LL0fNM8AI6AaK_QgMdb7ew,2353
 pyview/vendor/ibis/tree.py,sha256=hg8f-fKHeo6DE8R-QgAhdvEaZ8rKyz7p0nGwPy0CBTs,2509
 pyview/vendor/ibis/utils.py,sha256=nLSaxPR9vMphzV9qinlz_Iurv9c49Ps6Knv8vyNlewU,2768
-pyview/ws_handler.py,sha256=CY1iDx5GETjIkqhgFbo2fkE3FhrqucSdg4AjuJ2P0Qg,9041
-pyview_web-0.2.5.dist-info/LICENSE,sha256=M_bADaBm9_MV9llX3lCicksLhwk3eZUjA2srE0uUWr0,1071
-pyview_web-0.2.5.dist-info/METADATA,sha256=3g39-VhWx0gWkq1B46NAkTTTDSqnOr692TkFZtgOrNo,5243
-pyview_web-0.2.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-pyview_web-0.2.5.dist-info/entry_points.txt,sha256=GAT-ic-VYmmSMUSUVKdV1bp4w-vgEeVP-XzElvarQ9U,42
-pyview_web-0.2.5.dist-info/RECORD,,
+pyview/ws_handler.py,sha256=QAmD_ANP6UCgghMSFjPcyaQP9R1eKjoebq4CxnUDrbU,14492
+pyview_web-0.3.0.dist-info/LICENSE,sha256=M_bADaBm9_MV9llX3lCicksLhwk3eZUjA2srE0uUWr0,1071
+pyview_web-0.3.0.dist-info/METADATA,sha256=8VCRjuMu-E2wWussavO1C4Sk1bSTZKKKQIlZhXPy_Qo,5199
+pyview_web-0.3.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+pyview_web-0.3.0.dist-info/entry_points.txt,sha256=GAT-ic-VYmmSMUSUVKdV1bp4w-vgEeVP-XzElvarQ9U,42
+pyview_web-0.3.0.dist-info/RECORD,,

pyview/test_csrf.py

@@ -1,21 +0,0 @@
-from pyview.csrf import generate_csrf_token, validate_csrf_token
-
-
-def test_can_validate_tokens():
-    t = generate_csrf_token("test")
-    assert validate_csrf_token(t, "test")
-
-
-def test_can_validate_tokens_with_salt():
-    t = generate_csrf_token("test", salt="test-salt")
-    assert validate_csrf_token(t, "test", salt="test-salt")
-
-
-def test_can_validate_tokens_with_different_salt():
-    t = generate_csrf_token("test", salt="test-salt")
-    assert not validate_csrf_token(t, "test", salt="test-salt-2")
-
-
-def test_can_validate_tokens_with_different_value():
-    t = generate_csrf_token("test", salt="test-salt")
-    assert not validate_csrf_token(t, "test-2", salt="test-salt")