pyview-web 0.0.25__tar.gz → 0.2.0__tar.gz

{pyview_web-0.0.25 → pyview_web-0.2.0}/PKG-INFO

@@ -1,17 +1,15 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: pyview-web
-Version: 0.0.25
+Version: 0.2.0
 Summary: LiveView in Python
-Home-page: https://pyview.rocks
 License: MIT
 Keywords: web,api,LiveView
 Author: Larry Ogrodnek
 Author-email: ogrodnek@gmail.com
-Requires-Python: >=3.9,<3.12
+Requires-Python: >=3.10,<3.13
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Web Environment
 Classifier: Framework :: AsyncIO
-Classifier: Framework :: FastAPI
 Classifier: Framework :: Pydantic
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
@@ -20,9 +18,9 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Internet
 Classifier: Topic :: Internet :: WWW/HTTP
@@ -36,10 +34,11 @@ Requires-Dist: APScheduler (==3.9.1.post1)
 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.7.1,<3.0.0)
-Requires-Dist: starlette (==0.37.2)
-Requires-Dist: uvicorn (==0.20.0)
+Requires-Dist: pydantic (>=2.9.2,<3.0.0)
+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.0.25 → pyview_web-0.2.0}/pyproject.toml

@@ -5,7 +5,7 @@ packages = [
   { include = "pyview" },
 ]
 
-version = "0.0.25"
+version = "0.2.0"
 description = "LiveView in Python"
 authors = ["Larry Ogrodnek <ogrodnek@gmail.com>"]
 license = "MIT"
@@ -29,34 +29,34 @@ classifiers = [
     "Development Status :: 4 - Beta",
     "Environment :: Web Environment",
     "Framework :: AsyncIO",
-    "Framework :: FastAPI",
     "Framework :: Pydantic",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
     "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
     "Topic :: Internet :: WWW/HTTP",
 ]
 
 [tool.poetry.dependencies]
-python = ">=3.9,<3.12"
-starlette = "0.37.2"
-uvicorn = "0.20.0"
+python = ">=3.10,<3.13"
+starlette = "0.40.0"
+uvicorn = "0.30.6"
 wsproto = "1.2.0"
 APScheduler = "3.9.1.post1"
 psutil = "^5.9.4"
 markupsafe = "^2.1.2"
 itsdangerous = "^2.1.2"
-pydantic = "^2.7.1"
+pydantic = "^2.9.2"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.2.0"
 black = "24.3.0"
-pyright = "1.1.292"
+pyright = "1.1.400"
 aiohttp = "^3.8.4"
+pytest-cov = "^6.1.1"
 
 [tool.poetry.group.profiling.dependencies]
 scalene = "^1.5.19"
@@ -73,6 +73,7 @@ build-backend = "poetry.core.masonry.api"
 [tool.pyright]
 exclude = [
     ".venv",
+    "examples",
     "examples/.venv",
     "**/vendor",
     "**/node_modules",

{pyview_web-0.0.25 → pyview_web-0.2.0}/pyview/__init__.py

@@ -1,7 +1,12 @@
 from pyview.live_view import LiveView
-from pyview.live_socket import LiveViewSocket
+from pyview.live_socket import (
+    LiveViewSocket,
+    is_connected,
+    ConnectedLiveViewSocket,
+    UnconnectedSocket,
+)
 from pyview.pyview import PyView, defaultRootTemplate
-from pyview.js import js
+from pyview.js import JsCommand
 from pyview.pyview import RootTemplateContext, RootTemplate
 
 __all__ = [
@@ -9,7 +14,9 @@ __all__ = [
     "LiveViewSocket",
     "PyView",
     "defaultRootTemplate",
-    "js",
+    "JsCommand",
     "RootTemplateContext",
     "RootTemplate",
+    "is_connected",
+    "ConnectedLiveViewSocket",
 ]

{pyview_web-0.0.25 → pyview_web-0.2.0}/pyview/changesets/changesets.py

@@ -1,4 +1,4 @@
-from typing import TypeVar, Any, Generic, Optional, Callable
+from typing import TypeVar, Any, Generic, Optional
 from pydantic import BaseModel, ValidationError
 from dataclasses import dataclass
 from types import SimpleNamespace
@@ -8,7 +8,7 @@ Base = TypeVar("Base", bound=BaseModel)
 
 @dataclass
 class ChangeSet(Generic[Base]):
-    cls: Callable[..., Base]
+    cls: type[Base]
     changes: dict[str, Any]
     errors: dict[str, Any]
     valid: bool
@@ -29,7 +29,7 @@ class ChangeSet(Generic[Base]):
 
     @property
     def fields(self) -> list[str]:
-        return self.cls.__fields__.keys()
+        return list(self.cls.model_fields)
 
     def save(self, payload: dict[str, Any]) -> Optional[Base]:
         self.errors = {}
@@ -58,5 +58,5 @@ class ChangeSet(Generic[Base]):
             self.valid = False
 
 
-def change_set(cls: Callable[..., Base]) -> ChangeSet[Base]:
+def change_set(cls: type[Base]) -> ChangeSet[Base]:
     return ChangeSet(cls, {}, {}, False)

pyview_web-0.2.0/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.0/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.0.25 → pyview_web-0.2.0}/pyview/live_socket.py

@@ -1,12 +1,22 @@
 from __future__ import annotations
 from starlette.websockets import WebSocket
 import json
-from typing import Any, TypeVar, Generic, TYPE_CHECKING, Optional
+from typing import (
+    Any,
+    TypeVar,
+    Generic,
+    TYPE_CHECKING,
+    Optional,
+    Union,
+    TypeAlias,
+    TypeGuard,
+)
 from urllib.parse import urlencode
 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
 
 
@@ -21,10 +31,14 @@ pub_sub_hub = PubSubHub()
 T = TypeVar("T")
 
 
+def is_connected(socket: LiveViewSocket[T]) -> TypeGuard["ConnectedLiveViewSocket[T]"]:
+    return socket.connected
+
+
 class UnconnectedSocket(Generic[T]):
     context: T
-    connected: bool = False
     live_title: Optional[str] = None
+    connected: bool = False
 
     def allow_upload(
         self, upload_name: str, constraints: UploadConstraints
@@ -32,7 +46,7 @@ class UnconnectedSocket(Generic[T]):
         return UploadConfig(name=upload_name, constraints=constraints)
 
 
-class LiveViewSocket(Generic[T]):
+class ConnectedLiveViewSocket(Generic[T]):
     context: T
     live_title: Optional[str] = None
     pending_events: list[tuple[str, Any]]
@@ -49,6 +63,10 @@ class LiveViewSocket(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)
 
@@ -81,12 +99,12 @@ class LiveViewSocket(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:
             await self.websocket.send_text(json.dumps(resp))
-        except Exception as e:
+        except Exception:
             for id in self.scheduled_jobs:
                 print("Removing job", id)
                 scheduler.remove_job(id)
@@ -143,3 +161,6 @@ class LiveViewSocket(Generic[T]):
             await self.liveview.disconnect(self)
         except Exception:
             pass
+
+
+LiveViewSocket: TypeAlias = Union[ConnectedLiveViewSocket[T], UnconnectedSocket[T]]

{pyview_web-0.0.25 → pyview_web-0.2.0}/pyview/live_view.py

@@ -1,5 +1,5 @@
 from typing import TypeVar, Generic, Optional, Union, Any
-from .live_socket import LiveViewSocket, UnconnectedSocket
+from .live_socket import LiveViewSocket, ConnectedLiveViewSocket
 from pyview.template import (
     LiveTemplate,
     template_file,
@@ -8,11 +8,11 @@ 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")
 
-AnySocket = Union[LiveViewSocket[T], UnconnectedSocket[T]]
 Session = dict[str, Any]
 
 # TODO: ideally this would always be a ParseResult, but we need to update push_patch
@@ -23,26 +23,26 @@ class LiveView(Generic[T]):
     def __init__(self):
         pass
 
-    async def mount(self, socket: AnySocket, session: Session):
+    async def mount(self, socket: LiveViewSocket[T], session: Session):
         pass
 
-    async def handle_event(self, event, payload, socket: LiveViewSocket[T]):
+    async def handle_event(self, event, payload, socket: ConnectedLiveViewSocket[T]):
         pass
 
-    async def handle_info(self, event: InfoEvent, socket: LiveViewSocket[T]):
+    async def handle_info(self, event: InfoEvent, socket: ConnectedLiveViewSocket[T]):
         pass
 
-    async def handle_params(self, url: URL, params, socket: AnySocket):
+    async def handle_params(self, url: URL, params, socket: LiveViewSocket[T]):
         pass
 
-    async def disconnect(self, socket: LiveViewSocket[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.0/pyview/meta.py

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

{pyview_web-0.0.25 → pyview_web-0.2.0}/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.0.25 → pyview_web-0.2.0}/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.0/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.2.0/pyview/template/live_template.py

@@ -0,0 +1,83 @@
+from pyview.vendor.ibis import Template
+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):
+    __dataclass_fields__: ClassVar[dict[str, Field[Any]]]
+
+
+Assigns = Union[dict[str, Any], DataclassInstance]
+
+
+# TODO: should we still support this?
+class DictConvertable(Protocol):
+    def asdict(self) -> dict[str, Any]: ...
+
+
+class LiveTemplate:
+    t: Template
+
+    def __init__(self, template: Template):
+        self.t = template
+
+    def tree(self, assigns: Assigns, meta: PyViewMeta) -> dict[str, Any]:
+        if not isinstance(assigns, dict):
+            assigns = serialize(assigns)
+        additional_context = apply_context_processors(meta)
+        return self.t.tree(additional_context | assigns)
+
+    def render(self, assigns: Assigns, meta: PyViewMeta) -> str:
+        if not isinstance(assigns, dict):
+            assigns = asdict(assigns)
+        additional_context = apply_context_processors(meta)
+        return self.t.render(additional_context | 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()
+
+
+class RenderedContent(Protocol):
+    def tree(self) -> dict[str, Any]: ...
+
+    def text(self) -> str: ...
+
+
+class LiveRender:
+    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, self.meta)
+
+    def text(self) -> str:
+        return self.template.text(self.assigns, self.meta)
+
+
+_cache = {}
+
+
+def template_file(filename: str) -> Optional[LiveTemplate]:
+    """Renders a template file with the given assigns."""
+    if not os.path.isfile(filename):
+        return None
+
+    mtime = os.path.getmtime(filename)
+    if filename in _cache:
+        cached_mtime, cached_template = _cache[filename]
+        if cached_mtime == mtime:
+            return cached_template
+
+    with open(filename, "r") as f:
+        t = LiveTemplate(Template(f.read(), template_id=filename))
+        _cache[filename] = (mtime, t)
+        return t

{pyview_web-0.0.25 → pyview_web-0.2.0}/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.0.25 → pyview_web-0.2.0}/pyview/ws_handler.py

@@ -2,7 +2,7 @@ from typing import Optional, Any
 import json
 from starlette.websockets import WebSocket, WebSocketDisconnect
 from urllib.parse import urlparse, parse_qs
-from pyview.live_socket import LiveViewSocket
+from pyview.live_socket import ConnectedLiveViewSocket, LiveViewSocket
 from pyview.live_routes import LiveViewLookup
 from pyview.csrf import validate_csrf_token
 from pyview.session import deserialize_session
@@ -42,16 +42,22 @@ 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 = LiveViewSocket(websocket, topic, lv)
+                socket = ConnectedLiveViewSocket(websocket, topic, lv)
 
                 session = {}
                 if "session" in payload:
                     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)
 
@@ -75,7 +81,7 @@ class LiveSocketHandler:
             self.sessions -= 1
 
     async def handle_connected(
-        self, myJoinId, socket: LiveViewSocket, prev_rendered: dict[str, Any]
+        self, myJoinId, socket: ConnectedLiveViewSocket, prev_rendered: dict[str, Any]
     ):
         while True:
             message = await socket.websocket.receive()
@@ -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
@@ -235,8 +254,8 @@ class LiveSocketHandler:
                 )
 
 
-async def _render(socket: LiveViewSocket):
-    rendered = (await socket.liveview.render(socket.context)).tree()
+async def _render(socket: ConnectedLiveViewSocket):
+    rendered = (await socket.liveview.render(socket.context, socket.meta)).tree()
 
     if socket.live_title:
         rendered["t"] = socket.live_title

pyview_web-0.0.25/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.0.25/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()

pyview_web-0.0.25/pyview/template/live_template.py

@@ -1,75 +0,0 @@
-from pyview.vendor.ibis import Template
-from typing import Any, Union, Protocol, Optional
-from dataclasses import asdict
-from .serializer import serialize
-import os.path
-
-
-class DictConvertable(Protocol):
-    def asdict(self) -> dict[str, Any]:
-        ...
-
-
-Assigns = Union[dict[str, Any], DictConvertable]
-
-
-class LiveTemplate:
-    t: Template
-
-    def __init__(self, template: Template):
-        self.t = template
-
-    def tree(self, assigns: Assigns) -> dict[str, Any]:
-        if not isinstance(assigns, dict):
-            assigns = serialize(assigns)
-        return self.t.tree(assigns)
-
-    def render(self, assigns: Assigns) -> str:
-        if not isinstance(assigns, dict):
-            assigns = asdict(assigns)
-        return self.t.render(assigns)
-
-    def text(self, assigns: Assigns) -> str:
-        return self.render(assigns)
-
-    def debug(self) -> str:
-        return self.t.root_node.to_str()
-
-
-class RenderedContent(Protocol):
-    def tree(self) -> dict[str, Any]:
-        ...
-
-    def text(self) -> str:
-        ...
-
-
-class LiveRender:
-    def __init__(self, template: LiveTemplate, assigns: Any):
-        self.template = template
-        self.assigns = assigns
-
-    def tree(self) -> dict[str, Any]:
-        return self.template.tree(self.assigns)
-
-    def text(self) -> str:
-        return self.template.text(self.assigns)
-
-
-_cache = {}
-
-def template_file(filename: str) -> Optional[LiveTemplate]:
-    """Renders a template file with the given assigns."""
-    if not os.path.isfile(filename):
-        return None
-
-    mtime = os.path.getmtime(filename)
-    if filename in _cache:
-        cached_mtime, cached_template = _cache[filename]
-        if cached_mtime == mtime:
-            return cached_template
-
-    with open(filename, "r") as f:
-        t = LiveTemplate(Template(f.read()))
-        _cache[filename] = (mtime, t)
-        return t