pyview-web 0.0.25__py3-none-any.whl → 0.2.0__py3-none-any.whl

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/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/js.py

@@ -1,34 +1,120 @@
 import json
-from typing import Union
+from typing import Any, Optional
 from pyview.vendor.ibis import filters
+from pyview.template.context_processor import context_processor
+from dataclasses import dataclass
 
 
-JsArgs = Union[tuple[str, str], tuple[str, str, list[str]]]
+@context_processor
+def add_js(meta):
+    return {"js": JsCommands([])}
 
 
-@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)
+@filters.register("js.add_class")
+def js_add_class(js: "JsCommands", selector: str, *classes):
+    return js.add_class(selector, *classes)
 
 
-class Js:
-    def __init__(self, cmd: str, id: str, names: list[str] = []):
-        self.cmd = cmd
-        self.id = id
-        self.names = names
+@filters.register("js.remove_class")
+def js_remove_class(js: "JsCommands", selector: str, *classes):
+    return js.remove_class(selector, *classes)
 
-    def __str__(self):
-        opts = {
-            "to": self.id,
-            "time": 200,
-            "transition": [[], [], []],
-        }
 
-        if len(self.names) > 0:
-            opts["names"] = self.names
+@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)
+
 
-        return json.dumps([[self.cmd, opts]])
+@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/live_routes.py

@@ -1,20 +1,47 @@
 from pyview.live_view import LiveView
-from typing import Callable
+from typing import Callable, Any
+from starlette.routing import compile_path
 
 
 class LiveViewLookup:
     def __init__(self):
-        self.routes = {}
+        self.routes = []  # [(path_format, path_regex, param_convertors, lv)]
 
     def add(self, path: str, lv: Callable[[], LiveView]):
-        self.routes[path] = lv
+        path_regex, path_format, param_convertors = compile_path(path)
+        self.routes.append((path_format, path_regex, param_convertors, lv))
 
-    def get(self, path: str) -> LiveView:
-        lv = self.routes.get(path)
-        if not lv and path.endswith("/"):
-            lv = self.routes[path[:-1]]
+    def get(self, path: str) -> tuple[LiveView, dict[str, Any]]:
+        # Find all matching routes
+        matches = []
 
-        if not lv:
-            raise ValueError("No LiveView found for path: " + path)
+        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()
 
-        return lv()
+                # 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/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/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/meta.py

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

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/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/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/template/live_template.py

@@ -1,16 +1,22 @@
 from pyview.vendor.ibis import Template
-from typing import Any, Union, Protocol, Optional
-from dataclasses import asdict
+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 DictConvertable(Protocol):
-    def asdict(self) -> dict[str, Any]:
-        ...
+class DataclassInstance(Protocol):
+    __dataclass_fields__: ClassVar[dict[str, Field[Any]]]
+
 
+Assigns = Union[dict[str, Any], DataclassInstance]
 
-Assigns = Union[dict[str, Any], DictConvertable]
+
+# TODO: should we still support this?
+class DictConvertable(Protocol):
+    def asdict(self) -> dict[str, Any]: ...
 
 
 class LiveTemplate:
@@ -19,45 +25,47 @@ 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()
 
 
 class RenderedContent(Protocol):
-    def tree(self) -> dict[str, Any]:
-        ...
+    def tree(self) -> dict[str, Any]: ...
 
-    def text(self) -> str:
-        ...
+    def text(self) -> str: ...
 
 
 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 = {}
 
+
 def template_file(filename: str) -> Optional[LiveTemplate]:
     """Renders a template file with the given assigns."""
     if not os.path.isfile(filename):
@@ -70,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/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/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.dist-info → pyview_web-0.2.0.dist-info}/METADATA

@@ -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.dist-info → pyview_web-0.2.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyview/__init__.py,sha256=Pk-RgSkIG6fkLH3CwrF5tptoq7n72w0O73k2vAW4CAQ,374
+pyview/__init__.py,sha256=5RJ_KtwJvI_-_Vhb3-py5Qf78YdH1HHvAzZO1ddzzrU,518
 pyview/assets/js/app.js,sha256=XuuSgEMY4hx8v0OuEPwaa7trktu_vppL0tc3Bs9Fw7s,2524
 pyview/assets/package-lock.json,sha256=kFCrEUJc3G7VD7EsBQf6__EKQhaKAok-I5rrwiAoX0w,2425
 pyview/assets/package.json,sha256=E6xaX8KMUAektIIedLmI55jGnmlNMSeD2tgKYXWk1vg,151
@@ -6,20 +6,22 @@ pyview/auth/__init__.py,sha256=vMlirETRhD4va61NOzwg8VY8ep9wVOF96GznJGBmzD0,109
 pyview/auth/provider.py,sha256=fwriy2JZcOStutVXD-8VlMPAFXjILCM0l08lhTgmuyE,935
 pyview/auth/required.py,sha256=ZtNmLFth9nK39RxDiJkSzArXwS5Cvr55MUAzfJ1F2e0,1418
 pyview/changesets/__init__.py,sha256=55CLari2JHZtwy4hapHe7CqUyKjcP4dkM_t5d3CY2gU,46
-pyview/changesets/changesets.py,sha256=B1q1nXwI2iuZZQpE3P2T0PpwI21PHjqcsuIQmkKPCvI,1747
+pyview/changesets/changesets.py,sha256=hImmvB_jS6RyLr5Mas5L7DO_0d805jR3c41LKJlnNL4,1720
 pyview/csrf.py,sha256=VIURva9EJqXXYGC7engweh3SwDQCnHlhV2zWdcdnFqc,789
 pyview/events.py,sha256=Zv8G2F1XeXUk1wrnfomeFfxB0OPYmHdjSvxRjQew3No,125
-pyview/js.py,sha256=4OnPEfBfuvmekeQlm9444As4PLR22zLMIyyzQIIkmls,751
-pyview/live_routes.py,sha256=tsKFh2gmH2BWsjsZQZErzRp_-KiAZcn4lFKNLRIN5Nc,498
-pyview/live_socket.py,sha256=6SLEkEBzK-zIUNh_5j_OG5t6IHGTDNCpGXk7D7SMNJ4,4370
-pyview/live_view.py,sha256=A0vCCvHUy39_eEhRzDbYMEDzgpRqseZPjCnBAMjogxw,1406
+pyview/js.py,sha256=E6HMsUfXQjrcLqYq26ieeYuzTjBeZqfJwwOm3uSR4ME,3498
+pyview/live_routes.py,sha256=IN2Jmy8b1umcfx1R7ZgFXHZNbYDJp_kLIbADtDJknPM,1749
+pyview/live_socket.py,sha256=D8fg7UQSPCVEboxohbDAZuK7J1xBEEoDycVFUuDfZxI,4767
+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=xy8on2f-chU4JWVy6zGTDqjP8BW-kOoi16voNIgWRg4,2478
+pyview/pyview.py,sha256=UuAeHdmrcmu3q681NR8IVQ1-LcMBnWyT1vIuQdrLlhY,2666
 pyview/secret.py,sha256=HbaNpGAkFs4uxMVAmk9HwE3FIehg7dmwEOlED7C9moM,363
 pyview/session.py,sha256=nC8ExyVwfCgQfx9T-aJGyFhr2C7jsrEY_QFkaXtP28U,432
 pyview/static/assets/app.js,sha256=QoXfdcOCYwVYJftvjsIIVwFye7onaOJMxRpalyYqoMU,200029
-pyview/template/__init__.py,sha256=c5hLRfsF2fDOz8aOsoOgoCeBV6VBzdqN_Ktg3mYPw8A,509
-pyview/template/live_template.py,sha256=wSKyBw7ejpUY5qXUZdE36Jeeix8Of0CUq8eZdQwxXyg,1864
+pyview/template/__init__.py,sha256=0goMpA8-TCKcwHbhjvAgbPYnY929vBrwjc701t9RIQw,583
+pyview/template/context_processor.py,sha256=y07t7mhL7XjZNbwHnTTyXJvYhXabtuTukDScycAFjVc,312
+pyview/template/live_template.py,sha256=m8_1TCFGfpVkXyZOIWN6a3ksvsewPlo8vTzzPGDyEU0,2408
 pyview/template/render_diff.py,sha256=v7EVmn8oJdh809N0vnSLK8OiDs1BOpErF36y4VUo9ew,1214
 pyview/template/root_template.py,sha256=zCUs1bt8R7qynhBE0tTSEYfdkGtbeKNmPhwzRiFNdsI,2031
 pyview/template/serializer.py,sha256=WDZfqJr2LMlf36fUW2CmWc2aREc63553_y_GRP2-qYc,826
@@ -36,11 +38,11 @@ pyview/vendor/ibis/errors.py,sha256=gtRX3LjkdWEP4NaX8HXL_6OU2fCX16IBBSiGMG5wiY4,
 pyview/vendor/ibis/filters.py,sha256=M36KS6dlzfsb2NmHkbVuo8gJbiQ6aQjcHzXxHwZ3Afw,7042
 pyview/vendor/ibis/loaders.py,sha256=NYW7_hlC7TRPDau37bgiOCsvsBgIPpUEpb1NbroUVUA,3457
 pyview/vendor/ibis/nodes.py,sha256=TgFt4q5MrVW3gC3PVitrs2LyXKllRveooM7XKydNATk,25617
-pyview/vendor/ibis/template.py,sha256=IX9z-Ig13yJyRnMqtB52eiRLe002qdIxnfa7fYEXLqM,2314
+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=Vi5aIoxz_Z9qOEcA5fgxsSoJtLz7n_ytbJ8vZiWDvGc,8473
-pyview_web-0.0.25.dist-info/LICENSE,sha256=M_bADaBm9_MV9llX3lCicksLhwk3eZUjA2srE0uUWr0,1071
-pyview_web-0.0.25.dist-info/METADATA,sha256=-UhlfnbHQaDx-Elu2KFZRxrV2brUwuJ2GAwFfrRWRGU,5276
-pyview_web-0.0.25.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pyview_web-0.0.25.dist-info/RECORD,,
+pyview/ws_handler.py,sha256=8iFKEse4TUaBzHF4xAcZiOqXaAgv4yB2CT0BKoW2Ny4,9319
+pyview_web-0.2.0.dist-info/LICENSE,sha256=M_bADaBm9_MV9llX3lCicksLhwk3eZUjA2srE0uUWr0,1071
+pyview_web-0.2.0.dist-info/METADATA,sha256=jWEXUjbxfTB87xaKUG2_NAnDB9Yz7BQ40Evr0bNGVK0,5256
+pyview_web-0.2.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+pyview_web-0.2.0.dist-info/RECORD,,

{pyview_web-0.0.25.dist-info → pyview_web-0.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 2.1.2
 Root-Is-Purelib: true
 Tag: py3-none-any