pyview-web 0.1.0__tar.gz → 0.2.1__tar.gz

{pyview_web-0.1.0 → pyview_web-0.2.1}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: pyview-web
-Version: 0.1.0
+Version: 0.2.1
 Summary: LiveView in Python
-Home-page: https://pyview.rocks
 License: MIT
 Keywords: web,api,LiveView
 Author: Larry Ogrodnek
@@ -36,9 +35,10 @@ 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: pydantic (>=2.9.2,<3.0.0)
-Requires-Dist: starlette (==0.38.5)
+Requires-Dist: starlette (==0.40.0)
 Requires-Dist: uvicorn (==0.30.6)
 Requires-Dist: wsproto (==1.2.0)
+Project-URL: Homepage, https://pyview.rocks
 Project-URL: Repository, https://github.com/ogrodnek/pyview
 Description-Content-Type: text/markdown
 

{pyview_web-0.1.0 → pyview_web-0.2.1}/pyproject.toml

@@ -5,7 +5,7 @@ packages = [
   { include = "pyview" },
 ]
 
-version = "0.1.0"
+version = "0.2.1"
 description = "LiveView in Python"
 authors = ["Larry Ogrodnek <ogrodnek@gmail.com>"]
 license = "MIT"
@@ -42,7 +42,7 @@ classifiers = [
 
 [tool.poetry.dependencies]
 python = ">=3.10,<3.13"
-starlette = "0.38.5"
+starlette = "0.40.0"
 uvicorn = "0.30.6"
 wsproto = "1.2.0"
 APScheduler = "3.9.1.post1"
@@ -54,8 +54,9 @@ pydantic = "^2.9.2"
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.2.0"
 black = "24.3.0"
-pyright = "1.1.380"
+pyright = "1.1.400"
 aiohttp = "^3.8.4"
+pytest-cov = "^6.1.1"
 
 [tool.poetry.group.profiling.dependencies]
 scalene = "^1.5.19"

{pyview_web-0.1.0 → pyview_web-0.2.1}/pyview/__init__.py

@@ -6,7 +6,7 @@ from pyview.live_socket import (
     UnconnectedSocket,
 )
 from pyview.pyview import PyView, defaultRootTemplate
-from pyview.js import js
+from pyview.js import JsCommand
 from pyview.pyview import RootTemplateContext, RootTemplate
 
 __all__ = [
@@ -14,7 +14,7 @@ __all__ = [
     "LiveViewSocket",
     "PyView",
     "defaultRootTemplate",
-    "js",
+    "JsCommand",
     "RootTemplateContext",
     "RootTemplate",
     "is_connected",

pyview_web-0.2.1/pyview/events/BaseEventHandler.py

@@ -0,0 +1,38 @@
+from typing import Callable
+import logging
+
+
+def event(*event_names):
+    """Decorator that marks methods as event handlers."""
+
+    def decorator(func):
+        func._event_names = event_names
+        return func
+
+    return decorator
+
+
+class BaseEventHandler:
+    """Base class for event handlers to handle dispatching events."""
+
+    _event_handlers: dict[str, Callable] = {}
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+        # Find all decorated methods and register them
+        cls._event_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
+
+    async def handle_event(self, event: str, payload: dict, socket):
+        handler = self._event_handlers.get(event)
+
+        if handler:
+            return await handler(self, event, payload, socket)
+        else:
+            logging.warning(f"Unhandled event: {event} {payload}")

pyview_web-0.2.1/pyview/events/__init__.py

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

pyview_web-0.2.1/pyview/js.py

@@ -0,0 +1,120 @@
+import json
+from typing import Any, Optional
+from pyview.vendor.ibis import filters
+from pyview.template.context_processor import context_processor
+from dataclasses import dataclass
+
+
+@context_processor
+def add_js(meta):
+    return {"js": JsCommands([])}
+
+
+@filters.register("js.add_class")
+def js_add_class(js: "JsCommands", selector: str, *classes):
+    return js.add_class(selector, *classes)
+
+
+@filters.register("js.remove_class")
+def js_remove_class(js: "JsCommands", selector: str, *classes):
+    return js.remove_class(selector, *classes)
+
+
+@filters.register("js.show")
+def js_show(js: "JsCommands", selector: str):
+    return js.show(selector)
+
+
+@filters.register("js.hide")
+def js_hide(js: "JsCommands", selector: str):
+    return js.hide(selector)
+
+
+@filters.register("js.toggle")
+def js_toggle(js: "JsCommands", selector: str):
+    return js.toggle(selector)
+
+
+@filters.register("js.dispatch")
+def js_dispatch(js: "JsCommands", event: str, selector: str):
+    return js.dispatch(event, selector)
+
+
+@filters.register("js.push")
+def js_push(js: "JsCommands", event: str, payload: Optional[dict[str, Any]] = None):
+    return js.push(event, payload)
+
+
+@filters.register("js.focus")
+def js_focus(js: "JsCommands", selector: str):
+    return js.focus(selector)
+
+
+@filters.register("js.focus_first")
+def js_focus_first(js: "JsCommands", selector: str):
+    return js.focus_first(selector)
+
+
+@filters.register("js.transition")
+def js_transition(js: "JsCommands", selector: str, transition: str, time: int = 200):
+    return js.transition(selector, transition, time)
+
+
+@dataclass
+class JsCommand:
+    cmd: str
+    opts: dict[str, Any]
+
+
+@dataclass
+class JsCommands:
+    commands: list[JsCommand]
+
+    def add(self, cmd: JsCommand) -> "JsCommands":
+        return JsCommands(self.commands + [cmd])
+
+    def show(self, selector: str) -> "JsCommands":
+        return self.add(JsCommand("show", {"to": selector}))
+
+    def hide(self, selector: str) -> "JsCommands":
+        return self.add(JsCommand("hide", {"to": selector}))
+
+    def toggle(self, selector: str) -> "JsCommands":
+        return self.add(JsCommand("toggle", {"to": selector}))
+
+    def add_class(self, selector: str, *classes: str) -> "JsCommands":
+        return self.add(JsCommand("add_class", {"to": selector, "names": classes}))
+
+    def remove_class(self, selector: str, *classes: str) -> "JsCommands":
+        return self.add(JsCommand("remove_class", {"to": selector, "names": classes}))
+
+    def dispatch(self, event: str, selector: str) -> "JsCommands":
+        return self.add(JsCommand("dispatch", {"to": selector, "event": event}))
+
+    def push(
+        self, event: str, payload: Optional[dict[str, Any]] = None
+    ) -> "JsCommands":
+        return self.add(
+            JsCommand(
+                "push", {"event": event} | ({"value": payload} if payload else {})
+            )
+        )
+
+    def focus(self, selector: str) -> "JsCommands":
+        return self.add(JsCommand("focus", {"to": selector}))
+
+    def focus_first(self, selector: str) -> "JsCommands":
+        return self.add(JsCommand("focus_first", {"to": selector}))
+
+    def transition(
+        self, selector: str, transition: str, time: int = 200
+    ) -> "JsCommands":
+        return self.add(
+            JsCommand(
+                "transition",
+                {"to": selector, "time": time, "transition": [[transition], [], []]},
+            )
+        )
+
+    def __str__(self):
+        return json.dumps([(c.cmd, c.opts) for c in self.commands])

pyview_web-0.2.1/pyview/live_routes.py

@@ -0,0 +1,47 @@
+from pyview.live_view import LiveView
+from typing import Callable, Any
+from starlette.routing import compile_path
+
+
+class LiveViewLookup:
+    def __init__(self):
+        self.routes = []  # [(path_format, path_regex, param_convertors, lv)]
+
+    def add(self, path: str, lv: Callable[[], LiveView]):
+        path_regex, path_format, param_convertors = compile_path(path)
+        self.routes.append((path_format, path_regex, param_convertors, lv))
+
+    def get(self, path: str) -> tuple[LiveView, dict[str, Any]]:
+        # Find all matching routes
+        matches = []
+
+        for path_format, path_regex, param_convertors, lv in self.routes:
+            match_obj = path_regex.match(path)
+            if match_obj is not None:
+                params = match_obj.groupdict()
+
+                # Convert path params using Starlette's convertors
+                for param_name, convertor in param_convertors.items():
+                    if param_name in params:
+                        params[param_name] = convertor.convert(params[param_name])
+
+                # Store the match with its priority information
+                has_params = bool(param_convertors)
+                matches.append((lv, params, has_params))
+
+        # Sort matches by priority: static routes (has_params=False) come first
+        matches.sort(key=lambda x: x[2])  # Sort by has_params (False comes before True)
+
+        if matches:
+            lv, params, _ = matches[0]
+            return lv(), params
+
+        # Check for trailing slash
+        if path.endswith("/"):
+            try:
+                return self.get(path[:-1])
+            except ValueError:
+                pass
+
+        # No matches found
+        raise ValueError(f"No LiveView found for path: {path}")

{pyview_web-0.1.0 → pyview_web-0.2.1}/pyview/live_socket.py

@@ -16,6 +16,7 @@ from apscheduler.schedulers.asyncio import AsyncIOScheduler
 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
 import datetime
 
 
@@ -62,6 +63,10 @@ class ConnectedLiveViewSocket(Generic[T]):
         self.pending_events = []
         self.upload_manager = UploadManager()
 
+    @property
+    def meta(self) -> PyViewMeta:
+        return PyViewMeta()
+
     async def subscribe(self, topic: str):
         await self.pub_sub.subscribe_topic_async(topic, self._topic_callback_internal)
 
@@ -94,7 +99,7 @@ class ConnectedLiveViewSocket(Generic[T]):
 
     async def send_info(self, event: InfoEvent):
         await self.liveview.handle_info(event, self)
-        r = await self.liveview.render(self.context)
+        r = await self.liveview.render(self.context, self.meta)
         resp = [None, None, self.topic, "diff", self.diff(r.tree())]
 
         try:

{pyview_web-0.1.0 → pyview_web-0.2.1}/pyview/live_view.py

@@ -8,6 +8,7 @@ from pyview.template import (
     find_associated_file,
 )
 from pyview.events import InfoEvent
+from pyview.meta import PyViewMeta
 from urllib.parse import ParseResult
 
 T = TypeVar("T")
@@ -37,11 +38,11 @@ class LiveView(Generic[T]):
     async def disconnect(self, socket: ConnectedLiveViewSocket[T]):
         pass
 
-    async def render(self, assigns: T) -> RenderedContent:
+    async def render(self, assigns: T, meta: PyViewMeta) -> RenderedContent:
         html_render = _find_render(self)
 
         if html_render:
-            return LiveRender(html_render, assigns)
+            return LiveRender(html_render, assigns, meta)
 
         raise NotImplementedError()
 

pyview_web-0.2.1/pyview/meta.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class PyViewMeta:
+    pass

{pyview_web-0.1.0 → pyview_web-0.2.1}/pyview/pyview.py

@@ -1,8 +1,7 @@
 from starlette.applications import Starlette
-from starlette.websockets import WebSocket
 from starlette.responses import HTMLResponse
 from starlette.middleware.gzip import GZipMiddleware
-from starlette.routing import Route
+from starlette.routing import Route, WebSocketRoute
 from starlette.requests import Request
 import uuid
 from urllib.parse import parse_qs, urlparse
@@ -11,6 +10,7 @@ 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 .ws_handler import LiveSocketHandler
 from .live_view import LiveView
 from .live_routes import LiveViewLookup
@@ -31,10 +31,7 @@ class PyView(Starlette):
         self.view_lookup = LiveViewLookup()
         self.live_handler = LiveSocketHandler(self.view_lookup)
 
-        async def live_websocket_endpoint(websocket: WebSocket):
-            await self.live_handler.handle(websocket)
-
-        self.add_websocket_route("/live/websocket", live_websocket_endpoint)
+        self.routes.append(WebSocketRoute("/live/websocket", self.live_handler.handle))
         self.add_middleware(GZipMiddleware)
 
     def add_live_view(self, path: str, view: type[LiveView]):
@@ -53,14 +50,24 @@ async def liveview_container(
 ):
     url = request.url
     path = url.path
-    lv: LiveView = view_lookup.get(path)
+    lv, path_params = view_lookup.get(path)
     s = UnconnectedSocket()
 
     session = request.session if "session" in request.scope else {}
 
     await lv.mount(s, session)
-    await lv.handle_params(urlparse(url._url), parse_qs(url.query), s)
-    r = await lv.render(s.context)
+
+    # Parse query parameters
+    query_params = parse_qs(url.query)
+
+    # Merge path parameters with query parameters
+    # Path parameters take precedence in case of conflict
+    merged_params = {**query_params, **path_params}
+
+    # Pass merged parameters to handle_params
+    await lv.handle_params(urlparse(url._url), merged_params, s)
+
+    r = await lv.render(s.context, PyViewMeta())
 
     liveview_css = find_associated_css(lv)
 

{pyview_web-0.1.0 → pyview_web-0.2.1}/pyview/template/__init__.py

@@ -2,6 +2,7 @@ from pyview.vendor.ibis import Template
 from .live_template import LiveTemplate, template_file, RenderedContent, LiveRender
 from .root_template import RootTemplate, RootTemplateContext, defaultRootTemplate
 from .utils import find_associated_css, find_associated_file
+from .context_processor import context_processor
 
 __all__ = [
     "Template",
@@ -14,4 +15,5 @@ __all__ = [
     "defaultRootTemplate",
     "find_associated_css",
     "find_associated_file",
+    "context_processor",
 ]

pyview_web-0.2.1/pyview/template/context_processor.py

@@ -0,0 +1,17 @@
+from pyview.meta import PyViewMeta
+
+context_processors = []
+
+
+def context_processor(func):
+    context_processors.append(func)
+    return func
+
+
+def apply_context_processors(meta: PyViewMeta):
+    context = {}
+
+    for processor in context_processors:
+        context.update(processor(meta))
+
+    return context

{pyview_web-0.1.0 → pyview_web-0.2.1}/pyview/template/live_template.py

@@ -3,6 +3,8 @@ from typing import Any, Union, Protocol, Optional, ClassVar
 from dataclasses import asdict, Field
 from .serializer import serialize
 import os.path
+from pyview.template.context_processor import apply_context_processors
+from pyview.meta import PyViewMeta
 
 
 class DataclassInstance(Protocol):
@@ -23,18 +25,20 @@ class LiveTemplate:
     def __init__(self, template: Template):
         self.t = template
 
-    def tree(self, assigns: Assigns) -> dict[str, Any]:
+    def tree(self, assigns: Assigns, meta: PyViewMeta) -> dict[str, Any]:
         if not isinstance(assigns, dict):
             assigns = serialize(assigns)
-        return self.t.tree(assigns)
+        additional_context = apply_context_processors(meta)
+        return self.t.tree(additional_context | assigns)
 
-    def render(self, assigns: Assigns) -> str:
+    def render(self, assigns: Assigns, meta: PyViewMeta) -> str:
         if not isinstance(assigns, dict):
             assigns = asdict(assigns)
-        return self.t.render(assigns)
+        additional_context = apply_context_processors(meta)
+        return self.t.render(additional_context | assigns)
 
-    def text(self, assigns: Assigns) -> str:
-        return self.render(assigns)
+    def text(self, assigns: Assigns, meta: PyViewMeta) -> str:
+        return self.render(assigns, meta)
 
     def debug(self) -> str:
         return self.t.root_node.to_str()
@@ -47,15 +51,16 @@ class RenderedContent(Protocol):
 
 
 class LiveRender:
-    def __init__(self, template: LiveTemplate, assigns: Any):
+    def __init__(self, template: LiveTemplate, assigns: Any, meta: PyViewMeta):
         self.template = template
         self.assigns = assigns
+        self.meta = meta
 
     def tree(self) -> dict[str, Any]:
-        return self.template.tree(self.assigns)
+        return self.template.tree(self.assigns, self.meta)
 
     def text(self) -> str:
-        return self.template.text(self.assigns)
+        return self.template.text(self.assigns, self.meta)
 
 
 _cache = {}
@@ -73,6 +78,6 @@ def template_file(filename: str) -> Optional[LiveTemplate]:
             return cached_template
 
     with open(filename, "r") as f:
-        t = LiveTemplate(Template(f.read()))
+        t = LiveTemplate(Template(f.read(), template_id=filename))
         _cache[filename] = (mtime, t)
         return t

{pyview_web-0.1.0 → pyview_web-0.2.1}/pyview/vendor/ibis/template.py

@@ -10,6 +10,7 @@ class Template:
     def __init__(self, template_string, template_id="UNIDENTIFIED"):
         self.root_node = ibis.compiler.compile(template_string, template_id)
         self.blocks = self._register_blocks(self.root_node, {})
+        self.template_id = template_id
 
     def __str__(self):
         return str(self.root_node)

{pyview_web-0.1.0 → pyview_web-0.2.1}/pyview/ws_handler.py

@@ -42,7 +42,7 @@ class LiveSocketHandler:
                 self.myJoinId = topic
 
                 url = urlparse(payload["url"])
-                lv = self.routes.get(url.path)
+                lv, path_params = self.routes.get(url.path)
                 await self.check_auth(websocket, lv)
                 socket = ConnectedLiveViewSocket(websocket, topic, lv)
 
@@ -51,7 +51,13 @@ class LiveSocketHandler:
                     session = deserialize_session(payload["session"])
 
                 await lv.mount(socket, session)
-                await lv.handle_params(url, parse_qs(url.query), socket)
+
+                # Parse query parameters and merge with path parameters
+                query_params = parse_qs(url.query)
+                merged_params = {**query_params, **path_params}
+
+                # Pass merged parameters to handle_params
+                await lv.handle_params(url, merged_params, socket)
 
                 rendered = await _render(socket)
 
@@ -129,7 +135,20 @@ class LiveSocketHandler:
                 lv = socket.liveview
                 url = urlparse(payload["url"])
 
-                await lv.handle_params(url, parse_qs(url.query), socket)
+                # Extract and merge parameters
+                query_params = parse_qs(url.query)
+                path_params = {}
+
+                # We need to get path params for the new URL
+                try:
+                    # TODO: I don't think this is actually going to work...
+                    _, path_params = self.routes.get(url.path)
+                except ValueError:
+                    pass  # Handle case where the path doesn't match any route
+
+                merged_params = {**query_params, **path_params}
+
+                await lv.handle_params(url, merged_params, socket)
                 rendered = await _render(socket)
                 diff = calc_diff(prev_rendered, rendered)
                 prev_rendered = rendered
@@ -236,7 +255,7 @@ class LiveSocketHandler:
 
 
 async def _render(socket: ConnectedLiveViewSocket):
-    rendered = (await socket.liveview.render(socket.context)).tree()
+    rendered = (await socket.liveview.render(socket.context, socket.meta)).tree()
 
     if socket.live_title:
         rendered["t"] = socket.live_title

pyview_web-0.1.0/pyview/js.py

@@ -1,34 +0,0 @@
-import json
-from typing import Union
-from pyview.vendor.ibis import filters
-
-
-JsArgs = Union[tuple[str, str], tuple[str, str, list[str]]]
-
-
-@filters.register
-def js(args: JsArgs):
-    if len(args) > 2:
-        cmd, id, names = args  # type: ignore
-        return Js(cmd, id, names)
-    cmd, id = args  # type: ignore
-    return Js(cmd, id)
-
-
-class Js:
-    def __init__(self, cmd: str, id: str, names: list[str] = []):
-        self.cmd = cmd
-        self.id = id
-        self.names = names
-
-    def __str__(self):
-        opts = {
-            "to": self.id,
-            "time": 200,
-            "transition": [[], [], []],
-        }
-
-        if len(self.names) > 0:
-            opts["names"] = self.names
-
-        return json.dumps([[self.cmd, opts]])

pyview_web-0.1.0/pyview/live_routes.py

@@ -1,20 +0,0 @@
-from pyview.live_view import LiveView
-from typing import Callable
-
-
-class LiveViewLookup:
-    def __init__(self):
-        self.routes = {}
-
-    def add(self, path: str, lv: Callable[[], LiveView]):
-        self.routes[path] = lv
-
-    def get(self, path: str) -> LiveView:
-        lv = self.routes.get(path)
-        if not lv and path.endswith("/"):
-            lv = self.routes[path[:-1]]
-
-        if not lv:
-            raise ValueError("No LiveView found for path: " + path)
-
-        return lv()