pyview-web 0.2.2__tar.gz → 0.2.4__tar.gz

{pyview_web-0.2.2 → pyview_web-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyview-web
-Version: 0.2.2
+Version: 0.2.4
 Summary: LiveView in Python
 License: MIT
 Keywords: web,api,LiveView

{pyview_web-0.2.2 → pyview_web-0.2.4}/pyproject.toml

@@ -5,7 +5,7 @@ packages = [
   { include = "pyview" },
 ]
 
-version = "0.2.2"
+version = "0.2.4"
 description = "LiveView in Python"
 authors = ["Larry Ogrodnek <ogrodnek@gmail.com>"]
 license = "MIT"

pyview_web-0.2.4/pyview/async_stream_runner.py

@@ -0,0 +1,65 @@
+import asyncio
+import uuid
+import logging
+from typing import Any, AsyncGenerator, Callable, Optional
+from pyview.events.info_event import InfoEvent, InfoEventScheduler
+
+
+class AsyncStreamRunner:
+    def __init__(self, scheduler: InfoEventScheduler):
+        self._stream_tasks: dict[str, asyncio.Task] = {}
+        self._scheduler = scheduler
+
+    def start_stream(
+        self,
+        gen: AsyncGenerator[Any, None],
+        *,
+        on_yield: Callable[[Any], InfoEvent],
+        on_done: Optional[InfoEvent] = None,
+        on_error: Optional[Callable[[Exception], InfoEvent]] = None,
+        on_cancel: Optional[InfoEvent] = None,
+    ) -> str:
+        """
+        Run `gen` in the background, returning an op_id you can later use
+        to cancel.  Hooks:
+
+        - on_yield(item)  → scheduled per chunk
+        - on_done        → scheduled once at normal completion
+        - on_error(exc)  → scheduled on unexpected exception
+        - on_cancel      → scheduled if the task is cancelled
+        """
+        task_id = uuid.uuid4().hex
+
+        async def driver():
+            try:
+                async for item in gen:
+                    self._scheduler.schedule_info_once(on_yield(item))
+            except asyncio.CancelledError:
+                # user-requested cancellation
+                if on_cancel:
+                    self._scheduler.schedule_info_once(on_cancel)
+                # swallow so it doesn’t log as an “error”
+            except Exception as exc:
+                if on_error:
+                    self._scheduler.schedule_info_once(on_error(exc))
+                else:
+                    logging.exception(f"Error in stream {task_id}", exc_info=True)
+            else:
+                if on_done:
+                    self._scheduler.schedule_info_once(on_done)
+            finally:
+                self._stream_tasks.pop(task_id, None)
+
+        task = asyncio.create_task(driver())
+        self._stream_tasks[task_id] = task
+        return task_id
+
+    def cancel_stream(self, task_id: str) -> bool:
+        """
+        Cancel a running stream.  Returns True if a task was found & cancelled.
+        """
+        task = self._stream_tasks.get(task_id)
+        if not task:
+            return False
+        task.cancel()
+        return True

{pyview_web-0.2.2 → pyview_web-0.2.4}/pyview/events/BaseEventHandler.py

@@ -1,6 +1,9 @@
-from typing import Callable
+from typing import Callable, TYPE_CHECKING
 import logging
 
+if TYPE_CHECKING:
+    from pyview.live_view import InfoEvent
+
 
 def event(*event_names):
     """Decorator that marks methods as event handlers."""
@@ -12,22 +15,37 @@ def event(*event_names):
     return decorator
 
 
+def info(*info_names):
+    """Decorator that marks methods as info handlers."""
+
+    def decorator(func):
+        func._info_names = info_names
+        return func
+
+    return decorator
+
+
 class BaseEventHandler:
-    """Base class for event handlers to handle dispatching events."""
+    """Base class for event handlers to handle dispatching events and info."""
 
     _event_handlers: dict[str, Callable] = {}
+    _info_handlers: dict[str, Callable] = {}
 
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
 
         # Find all decorated methods and register them
         cls._event_handlers = {}
+        cls._info_handlers = {}
         for attr_name in dir(cls):
             if not attr_name.startswith("_"):
                 attr = getattr(cls, attr_name)
                 if hasattr(attr, "_event_names"):
                     for event_name in attr._event_names:
                         cls._event_handlers[event_name] = attr
+                if hasattr(attr, "_info_names"):
+                    for info_name in attr._info_names:
+                        cls._info_handlers[info_name] = attr
 
     async def handle_event(self, event: str, payload: dict, socket):
         handler = self._event_handlers.get(event)
@@ -36,3 +54,11 @@ class BaseEventHandler:
             return await handler(self, event, payload, socket)
         else:
             logging.warning(f"Unhandled event: {event} {payload}")
+
+    async def handle_info(self, info: "InfoEvent", socket):
+        handler = self._info_handlers.get(info.name)
+
+        if handler:
+            return await handler(self, info, socket)
+        else:
+            logging.warning(f"Unhandled info: {info.name} {info}")

pyview_web-0.2.4/pyview/events/__init__.py

@@ -0,0 +1,4 @@
+from .BaseEventHandler import BaseEventHandler, event, info
+from .info_event import InfoEvent
+
+__all__ = ["BaseEventHandler", "event", "info", "InfoEvent"]

pyview_web-0.2.4/pyview/events/info_event.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+from typing import Any, Optional, Protocol
+
+
+@dataclass
+class InfoEvent:
+    name: str
+    payload: Any = None
+
+
+class InfoEventScheduler(Protocol):
+    def schedule_info(self, event: InfoEvent, seconds: float):
+        pass
+
+    def schedule_info_once(self, event: InfoEvent, seconds: Optional[float] = None):
+        pass

{pyview_web-0.2.2 → pyview_web-0.2.4}/pyview/live_socket.py

@@ -17,7 +17,9 @@ from pyview.vendor.flet.pubsub import PubSubHub, PubSub
 from pyview.events import InfoEvent
 from pyview.uploads import UploadConstraints, UploadConfig, UploadManager
 from pyview.meta import PyViewMeta
+from pyview.template.render_diff import calc_diff
 import datetime
+from pyview.async_stream_runner import AsyncStreamRunner
 
 
 if TYPE_CHECKING:
@@ -50,8 +52,8 @@ class ConnectedLiveViewSocket(Generic[T]):
     context: T
     live_title: Optional[str] = None
     pending_events: list[tuple[str, Any]]
-
     upload_manager: UploadManager
+    prev_rendered: Optional[dict[str, Any]] = None
 
     def __init__(self, websocket: WebSocket, topic: str, liveview: LiveView):
         self.websocket = websocket
@@ -62,6 +64,7 @@ class ConnectedLiveViewSocket(Generic[T]):
         self.pub_sub = PubSub(pub_sub_hub, topic)
         self.pending_events = []
         self.upload_manager = UploadManager()
+        self.stream_runner = AsyncStreamRunner(self)
 
     @property
     def meta(self) -> PyViewMeta:
@@ -93,9 +96,13 @@ class ConnectedLiveViewSocket(Generic[T]):
         )
 
     def diff(self, render: dict[str, Any]) -> dict[str, Any]:
-        # TODO: not a real diff
-        del render["s"]
-        return render
+        if self.prev_rendered:
+            diff = calc_diff(self.prev_rendered, render)
+        else:
+            diff = render
+
+        self.prev_rendered = render
+        return diff
 
     async def send_info(self, event: InfoEvent):
         await self.liveview.handle_info(event, self)

{pyview_web-0.2.2 → pyview_web-0.2.4}/pyview/ws_handler.py

@@ -1,4 +1,4 @@
-from typing import Optional, Any
+from typing import Optional
 import json
 from starlette.websockets import WebSocket, WebSocketDisconnect
 from urllib.parse import urlparse, parse_qs
@@ -8,7 +8,6 @@ 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.template.render_diff import calc_diff
 
 
 class AuthException(Exception):
@@ -60,6 +59,7 @@ class LiveSocketHandler:
                 await lv.handle_params(url, merged_params, socket)
 
                 rendered = await _render(socket)
+                socket.prev_rendered = rendered
 
                 resp = [
                     joinRef,
@@ -70,7 +70,7 @@ class LiveSocketHandler:
                 ]
 
                 await self.manager.send_personal_message(json.dumps(resp), websocket)
-                await self.handle_connected(topic, socket, rendered)
+                await self.handle_connected(topic, socket)
 
         except WebSocketDisconnect:
             if socket:
@@ -80,9 +80,7 @@ class LiveSocketHandler:
             await websocket.close()
             self.sessions -= 1
 
-    async def handle_connected(
-        self, myJoinId, socket: ConnectedLiveViewSocket, prev_rendered: dict[str, Any]
-    ):
+    async def handle_connected(self, myJoinId, socket: ConnectedLiveViewSocket):
         while True:
             message = await socket.websocket.receive()
             [joinRef, mesageRef, topic, event, payload] = parse_message(message)
@@ -114,8 +112,7 @@ class LiveSocketHandler:
                     {} if not socket.pending_events else {"e": socket.pending_events}
                 )
 
-                diff = calc_diff(prev_rendered, rendered)
-                prev_rendered = rendered
+                diff = socket.diff(rendered)
 
                 socket.pending_events = []
 
@@ -150,8 +147,7 @@ class LiveSocketHandler:
 
                 await lv.handle_params(url, merged_params, socket)
                 rendered = await _render(socket)
-                diff = calc_diff(prev_rendered, rendered)
-                prev_rendered = rendered
+                diff = socket.diff(rendered)
 
                 resp = [
                     joinRef,
@@ -171,8 +167,7 @@ class LiveSocketHandler:
                 )
 
                 rendered = await _render(socket)
-                diff = calc_diff(prev_rendered, rendered)
-                prev_rendered = rendered
+                diff = socket.diff(rendered)
 
                 resp = [
                     joinRef,
@@ -238,8 +233,7 @@ class LiveSocketHandler:
             if event == "progress":
                 socket.upload_manager.update_progress(joinRef, payload)
                 rendered = await _render(socket)
-                diff = calc_diff(prev_rendered, rendered)
-                prev_rendered = rendered
+                diff = socket.diff(rendered)
 
                 resp = [
                     joinRef,

pyview_web-0.2.2/pyview/events/__init__.py

@@ -1,4 +0,0 @@
-from .BaseEventHandler import BaseEventHandler, event
-from .info_event import InfoEvent
-
-__all__ = ["BaseEventHandler", "event", "InfoEvent"]

pyview_web-0.2.2/pyview/events/info_event.py

@@ -1,8 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-
-
-@dataclass
-class InfoEvent:
-    name: str
-    payload: Any = None