pyview-web 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

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/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/events/__init__.py

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

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

@@ -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/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/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

@@ -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/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

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

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

@@ -1,4 +1,4 @@
-pyview/__init__.py,sha256=PG8coDKOMFTBuG9e3XxHJX1LipT0VDeki8CjDO-ZTG4,504
+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
@@ -8,18 +8,22 @@ pyview/auth/required.py,sha256=ZtNmLFth9nK39RxDiJkSzArXwS5Cvr55MUAzfJ1F2e0,1418
 pyview/changesets/__init__.py,sha256=55CLari2JHZtwy4hapHe7CqUyKjcP4dkM_t5d3CY2gU,46
 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=BylR8AiMLP0ZF8Lm2NxE1DZq9AX2g1YkcrNuK2a_tLY,4644
-pyview/live_view.py,sha256=3q-n1QoZR-JwPac4Sece_Q3nG3Kj6nEyVQwzxGqVt44,1396
+pyview/events/BaseEventHandler.py,sha256=RIv1vYn-sNIAfPNAaRg5iJvM--0ZlQHt3X7av_GR0sw,1138
+pyview/events/__init__.py,sha256=5qQhZUjBwbnL9SrQ9FWHNgrEgDETCI3ysMREx7Tab4E,142
+pyview/events/info_event.py,sha256=Zv8G2F1XeXUk1wrnfomeFfxB0OPYmHdjSvxRjQew3No,125
+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=JmHHuH6mu4OF-M6pZGTP3vgQWZizp0YS9q1QgtggD9g,1993
+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 +40,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=y0LTo9ug33KN3iyBxeaLrv7Vx0kVw1IedVvxO8wm7Tg,8525
-pyview_web-0.1.0.dist-info/LICENSE,sha256=M_bADaBm9_MV9llX3lCicksLhwk3eZUjA2srE0uUWr0,1071
-pyview_web-0.1.0.dist-info/METADATA,sha256=ssECrZ4vS-1qy_XG3oVmRKbYnMlD75bG1vOJXt3C0nA,5244
-pyview_web-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pyview_web-0.1.0.dist-info/RECORD,,
+pyview/ws_handler.py,sha256=8iFKEse4TUaBzHF4xAcZiOqXaAgv4yB2CT0BKoW2Ny4,9319
+pyview_web-0.2.1.dist-info/LICENSE,sha256=M_bADaBm9_MV9llX3lCicksLhwk3eZUjA2srE0uUWr0,1071
+pyview_web-0.2.1.dist-info/METADATA,sha256=Od48u4VsUdsrfxHx0er1SGZNUgX4J5PBwI-9eIlQzm4,5256
+pyview_web-0.2.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+pyview_web-0.2.1.dist-info/RECORD,,

{pyview_web-0.1.0.dist-info → pyview_web-0.2.1.dist-info}/WHEEL

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