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

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

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

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

@@ -5,7 +5,7 @@ packages = [
   { include = "pyview" },
 ]
 
-version = "0.2.3"
+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.3 → 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.3 → pyview_web-0.2.4}/pyview/live_socket.py

@@ -19,6 +19,7 @@ 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:
@@ -63,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:

pyview_web-0.2.3/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.3/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