pyview-web 0.0.9a0__py3-none-any.whl → 0.0.20__py3-none-any.whl

pyview/__init__.py

@@ -3,3 +3,13 @@ from pyview.live_socket import LiveViewSocket
 from pyview.pyview import PyView, defaultRootTemplate
 from pyview.js import js
 from pyview.pyview import RootTemplateContext, RootTemplate
+
+__all__ = [
+    "LiveView",
+    "LiveViewSocket",
+    "PyView",
+    "defaultRootTemplate",
+    "js",
+    "RootTemplateContext",
+    "RootTemplate",
+]

pyview/assets/js/app.js

@@ -26,7 +26,7 @@ import { Socket } from "phoenix";
 import { LiveSocket } from "phoenix_live_view";
 import NProgress from "nprogress";
 
-let Hooks = {};
+let Hooks = window.Hooks ?? {};
 
 let scrollAt = () => {
   let scrollTop = document.documentElement.scrollTop || document.body.scrollTop;

pyview/live_socket.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
-from fastapi import WebSocket
+from starlette.websockets import WebSocket
 import json
 from typing import Any, TypeVar, Generic, TYPE_CHECKING, Optional
 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
 import datetime
 
 
@@ -25,10 +26,18 @@ class UnconnectedSocket(Generic[T]):
     connected: bool = False
     live_title: Optional[str] = None
 
+    def allow_upload(
+        self, upload_name: str, constraints: UploadConstraints
+    ) -> UploadConfig:
+        return UploadConfig(name=upload_name, constraints=constraints)
+
 
 class LiveViewSocket(Generic[T]):
     context: T
     live_title: Optional[str] = None
+    pending_events: list[tuple[str, Any]]
+
+    upload_manager: UploadManager
 
     def __init__(self, websocket: WebSocket, topic: str, liveview: LiveView):
         self.websocket = websocket
@@ -37,6 +46,8 @@ class LiveViewSocket(Generic[T]):
         self.scheduled_jobs = []
         self.connected = True
         self.pub_sub = PubSub(pub_sub_hub, topic)
+        self.pending_events = []
+        self.upload_manager = UploadManager()
 
     async def subscribe(self, topic: str):
         await self.pub_sub.subscribe_topic_async(topic, self._topic_callback_internal)
@@ -49,12 +60,18 @@ class LiveViewSocket(Generic[T]):
 
     def schedule_info(self, event, seconds):
         id = f"{self.topic}:{event}"
-        scheduler.add_job(self.send_info, args=[event], id=id, trigger="interval", seconds=seconds)
+        scheduler.add_job(
+            self.send_info, args=[event], id=id, trigger="interval", seconds=seconds
+        )
         self.scheduled_jobs.append(id)
 
-    def schedule_info_once(self, event):
+    def schedule_info_once(self, event, seconds=None):
         scheduler.add_job(
-            self.send_info, args=[event], trigger="date", run_date=datetime.datetime.now(), misfire_grace_time=None
+            self.send_info,
+            args=[event],
+            trigger="date",
+            run_date=datetime.datetime.now() + datetime.timedelta(seconds=seconds or 0),
+            misfire_grace_time=None,
         )
 
     def diff(self, render: dict[str, Any]) -> dict[str, Any]:
@@ -103,8 +120,26 @@ class LiveViewSocket(Generic[T]):
         except Exception as e:
             print("Error sending message", e)
 
+    async def push_event(self, event: str, value: dict[str, Any]):
+        self.pending_events.append((event, value))
+
+    def allow_upload(
+        self, upload_name: str, constraints: UploadConstraints
+    ) -> UploadConfig:
+        return self.upload_manager.allow_upload(upload_name, constraints)
+
     async def close(self):
         self.connected = False
         for id in self.scheduled_jobs:
             scheduler.remove_job(id)
         await self.pub_sub.unsubscribe_all_async()
+
+        try:
+            self.upload_manager.close()
+        except Exception:
+            pass
+
+        try:
+            await self.liveview.disconnect(self)
+        except Exception:
+            pass

pyview/live_view.py

@@ -3,12 +3,16 @@ from .live_socket import LiveViewSocket, UnconnectedSocket
 from pyview.template import LiveTemplate, template_file, RenderedContent, LiveRender
 import inspect
 from pyview.events import InfoEvent
+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
+URL = Union[ParseResult, str]
+
 
 class LiveView(Generic[T]):
     def __init__(self):
@@ -23,7 +27,10 @@ class LiveView(Generic[T]):
     async def handle_info(self, event: InfoEvent, socket: LiveViewSocket[T]):
         pass
 
-    async def handle_params(self, url, params, socket: AnySocket):
+    async def handle_params(self, url: URL, params, socket: AnySocket):
+        pass
+
+    async def disconnect(self, socket: LiveViewSocket[T]):
         pass
 
     async def render(self, assigns: T) -> RenderedContent:

pyview/phx_message.py

@@ -0,0 +1,55 @@
+from starlette.websockets import WebSocketDisconnect
+from starlette.types import Message
+import json
+
+
+def parse_message(message: Message) -> tuple[str, str, str, str, dict]:
+    if "text" in message:
+        data = message["text"]
+        [joinRef, mesageRef, topic, event, payload] = json.loads(data)
+        return joinRef, mesageRef, topic, event, payload
+
+    if "bytes" in message:
+        data = message["bytes"]
+        # TODO: need to handle these message types better
+        return BinaryUploadSerDe().deserialize(data)  # type: ignore
+
+    # {'type': 'websocket.disconnect', 'code': <CloseReason.NO_STATUS_RCVD: 1005>}
+    # TODO handle: other errors?
+    raise WebSocketDisconnect(message["code"])
+
+
+import struct
+
+
+class BinaryUploadSerDe:
+    def deserialize(self, encoded_data: bytes) -> tuple[str, str, str, str, bytes]:
+        offset = 0
+
+        # Read the kind (1 byte)
+        kind = struct.unpack_from("B", encoded_data, offset)[0]
+        offset += 1
+
+        # Read lengths (4 bytes total, 1 byte each)
+        join_ref_length = struct.unpack_from("B", encoded_data, offset)[0]
+        offset += 1
+        ref_length = struct.unpack_from("B", encoded_data, offset)[0]
+        offset += 1
+        topic_length = struct.unpack_from("B", encoded_data, offset)[0]
+        offset += 1
+        event_length = struct.unpack_from("B", encoded_data, offset)[0]
+        offset += 1
+
+        # Read the strings
+        join_ref = encoded_data[offset : offset + join_ref_length].decode("utf-8")
+        offset += join_ref_length
+        msg_ref = encoded_data[offset : offset + ref_length].decode("utf-8")
+        offset += ref_length
+        topic = encoded_data[offset : offset + topic_length].decode("utf-8")
+        offset += topic_length
+        event = encoded_data[offset : offset + event_length].decode("utf-8")
+        offset += event_length
+
+        # The remaining bytes are the payload
+        payload = encoded_data[offset:]
+        return join_ref, msg_ref, topic, event, payload

pyview/pyview.py

@@ -1,11 +1,11 @@
 from starlette.applications import Starlette
-from fastapi import WebSocket
-from fastapi.responses import HTMLResponse
+from starlette.websockets import WebSocket
+from starlette.responses import HTMLResponse
 from starlette.middleware.gzip import GZipMiddleware
 from starlette.routing import Route
 from starlette.requests import Request
 import uuid
-from urllib.parse import parse_qs
+from urllib.parse import parse_qs, urlparse
 
 from pyview.live_socket import UnconnectedSocket
 from pyview.csrf import generate_csrf_token
@@ -54,7 +54,7 @@ async def liveview_container(
     session = request.session if "session" in request.scope else {}
 
     await lv.mount(s, session)
-    await lv.handle_params(url, parse_qs(url.query), s)
+    await lv.handle_params(urlparse(url._url), parse_qs(url.query), s)
     r = await lv.render(s.context)
 
     id = str(uuid.uuid4())

pyview/static/assets/app.js

@@ -5459,7 +5459,8 @@ within:
 
   // assets/js/app.js
   var import_nprogress = __toESM(require_nprogress());
-  var Hooks2 = {};
+  var _a;
+  var Hooks2 = (_a = window.Hooks) != null ? _a : {};
   var scrollAt = () => {
     let scrollTop = document.documentElement.scrollTop || document.body.scrollTop;
     let scrollHeight = document.documentElement.scrollHeight || document.body.scrollHeight;

pyview/template/root_template.py

@@ -56,8 +56,8 @@ def _defaultRootTemplate(
       <meta charset="utf-8">
       <meta http-equiv="X-UA-Compatible" content="IE=edge">
       <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+      {css}      
       <script defer type="text/javascript" src="/static/assets/app.js"></script>
-      {css}
     </head>
     <body>"""
         )

pyview/uploads.py

@@ -0,0 +1,294 @@
+import datetime
+import uuid
+from pydantic import BaseModel, Field
+from typing import Optional, Any, Literal, Generator
+from dataclasses import dataclass, field
+from contextlib import contextmanager
+import os
+import tempfile
+
+
+@dataclass
+class ConstraintViolation:
+    ref: str
+    code: Literal["too_large", "too_many_files"]
+
+    @property
+    def message(self) -> str:
+        if self.code == "too_large":
+            return "File too large"
+        return "Too many files"
+
+
+class UploadEntry(BaseModel):
+    path: str
+    ref: str
+    name: str
+    size: int
+    type: str
+    upload_config: Optional["UploadConfig"] = None
+    uuid: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    valid: bool = True
+    errors: list[ConstraintViolation] = Field(default_factory=list)
+    progress: int = 0
+    preflighted: bool = False
+    cancelled: bool = False
+    done: bool = False
+    last_modified: int = Field(
+        default_factory=lambda: int(datetime.datetime.now().timestamp())
+    )
+
+
+def parse_entries(entries: list[dict]) -> list[UploadEntry]:
+    return [UploadEntry(**entry) for entry in entries]
+
+
+@dataclass
+class ActiveUpload:
+    ref: str
+    entry: UploadEntry
+    file: tempfile._TemporaryFileWrapper = field(init=False)
+
+    def __post_init__(self):
+        self.file = tempfile.NamedTemporaryFile(delete=False)
+
+    def close(self):
+        self.file.close()
+        os.remove(self.file.name)
+
+
+@dataclass
+class ActiveUploads:
+    uploads: dict[str, ActiveUpload] = field(default_factory=dict)
+
+    def add_upload(self, ref: str, entry: UploadEntry):
+        self.uploads[ref] = ActiveUpload(ref, entry)
+
+    def add_chunk(self, ref: str, chunk: bytes):
+        self.uploads[ref].file.write(chunk)
+        self.uploads[ref].file.flush()
+        self.uploads[ref].entry.progress = self.uploads[ref].file.tell()
+
+    def no_progress(self) -> bool:
+        return all(upload.entry.progress == 0 for upload in self.uploads.values())
+
+    def file_name(self, ref: str) -> str:
+        return self.uploads[ref].file.name
+
+    def join_ref_for_entry(self, ref: str) -> str:
+        return [
+            join_ref
+            for join_ref, upload in self.uploads.items()
+            if upload.entry.ref == ref
+        ][0]
+
+    def close(self):
+        for upload in self.uploads.values():
+            upload.close()
+
+
+class UploadConstraints(BaseModel):
+    max_file_size: int = 10 * 1024 * 1024  # 10MB
+    max_files: int = 10
+    accept: list[str] = Field(default_factory=lambda: ["image/*"])
+    chunk_size: int = 64 * 1024  # 64KB
+
+
+class UploadConfig(BaseModel):
+    name: str
+
+    entries_by_ref: dict[str, UploadEntry] = Field(default_factory=dict)
+    ref: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    errors: list[ConstraintViolation] = Field(default_factory=list)
+    autoUpload: bool = False
+    constraints: UploadConstraints = Field(default_factory=UploadConstraints)
+
+    uploads: ActiveUploads = Field(default_factory=ActiveUploads)
+
+    @property
+    def entries(self) -> list[UploadEntry]:
+        return list(self.entries_by_ref.values())
+
+    def cancel_entry(self, ref: str):
+        del self.entries_by_ref[ref]
+
+        # recheck constraints
+        self.errors.clear()
+        if len(self.entries_by_ref) > self.constraints.max_files:
+            self.errors.append(ConstraintViolation(ref=self.ref, code="too_many_files"))
+
+    def add_entries(self, entries: list[dict]):
+        parsed = parse_entries(entries)
+        for entry in parsed:
+            entry.upload_config = self
+            self.entries_by_ref[entry.ref] = entry
+            if entry.size > self.constraints.max_file_size:
+                entry.valid = False
+                entry.errors.append(
+                    ConstraintViolation(ref=entry.ref, code="too_large")
+                )
+
+        if len(self.entries_by_ref) > self.constraints.max_files:
+            self.errors.append(ConstraintViolation(ref=self.ref, code="too_many_files"))
+
+    def update_progress(self, ref: str, progress: int):
+        self.entries_by_ref[ref].progress = progress
+        self.entries_by_ref[ref].done = progress == 100
+
+    @contextmanager
+    def consume_uploads(self) -> Generator[list["ActiveUpload"], None, None]:
+        try:
+            upload_list = list(self.uploads.uploads.values())
+            yield upload_list
+        finally:
+            try:
+                self.uploads.close()
+            except Exception as e:
+                print("Error closing uploads", e)
+
+            self.uploads = ActiveUploads()
+            self.entries_by_ref = {}
+
+    def close(self):
+        self.uploads.close()
+
+
+class UploadManager:
+    upload_configs: dict[str, UploadConfig]
+    upload_config_join_refs: dict[str, UploadConfig]
+
+    def __init__(self):
+        self.upload_configs = {}
+        self.upload_config_join_refs = {}
+
+    def allow_upload(
+        self, upload_name: str, constraints: UploadConstraints
+    ) -> UploadConfig:
+        config = UploadConfig(name=upload_name, constraints=constraints)
+        self.upload_configs[upload_name] = config
+        return config
+
+    def config_for_name(self, upload_name: str) -> Optional[UploadConfig]:
+        return self.upload_configs.get(upload_name)
+
+    def config_for_ref(self, ref: str) -> Optional[UploadConfig]:
+        return [c for c in self.upload_configs.values() if c.ref == ref][0]
+
+    def maybe_process_uploads(self, qs: dict[str, Any], payload: dict[str, Any]):
+        if "uploads" in payload:
+            uploads = payload["uploads"]
+            config_key = qs["_target"][0]
+
+            config = self.config_for_name(config_key)
+            if config:
+                if config.ref in uploads:
+                    entries = uploads[config.ref]
+                    config.add_entries(entries)
+                else:
+                    print("can't find ref", config.ref)
+
+    def process_allow_upload(self, payload: dict[str, Any]) -> dict[str, Any]:
+        ref = payload["ref"]
+        config = self.config_for_ref(ref)
+
+        if not config:
+            print("Can't find config for ref", ref)
+            return {"error": [(ref, "not_found")]}
+
+        proposed_entries = payload["entries"]
+
+        errors = []
+        for entry in proposed_entries:
+            if entry["size"] > config.constraints.max_file_size:
+                errors.append(ConstraintViolation(ref=entry["ref"], code="too_large"))
+
+        if len(proposed_entries) > config.constraints.max_files:
+            errors.append(ConstraintViolation(ref=ref, code="too_many_files"))
+
+        if errors:
+            return {"error": [(e.ref, e.code) for e in errors]}
+
+        configJson = config.constraints.model_dump()
+        entryJson = {
+            e.ref: e.model_dump(exclude={"upload_config"}) for e in config.entries
+        }
+
+        return {"config": configJson, "entries": entryJson}
+
+    def add_upload(self, joinRef: str, payload: dict[str, Any]):
+        token = payload["token"]
+
+        config = self.config_for_name(token["path"])
+        if config:
+            self.upload_config_join_refs[joinRef] = config
+            entry = UploadEntry(**token)
+            config.uploads.add_upload(joinRef, entry)
+
+    def add_chunk(self, joinRef: str, chunk: bytes):
+        config = self.upload_config_join_refs[joinRef]
+        config.uploads.add_chunk(joinRef, chunk)
+        pass
+
+    def update_progress(self, joinRef: str, payload: dict[str, Any]):
+        upload_config_ref = payload["ref"]
+        entry_ref = payload["entry_ref"]
+        progress = int(payload["progress"])
+
+        config = self.config_for_ref(upload_config_ref)
+        if config:
+            config.update_progress(entry_ref, progress)
+
+            if progress == 100:
+                joinRef = config.uploads.join_ref_for_entry(entry_ref)
+                del self.upload_config_join_refs[joinRef]
+
+    def no_progress(self, joinRef) -> bool:
+        config = self.upload_config_join_refs[joinRef]
+        return config.uploads.no_progress()
+
+    def close(self):
+        for config in self.upload_configs.values():
+            config.close()
+        self.upload_configs = {}
+
+
+from markupsafe import Markup
+from pyview.vendor.ibis import filters
+
+
+@filters.register
+def live_file_input(config: Optional[UploadConfig]) -> Markup:
+    if not config:
+        return Markup("")
+
+    active_refs = ",".join([entry.ref for entry in config.entries])
+    done_refs = ",".join([entry.ref for entry in config.entries if entry.done])
+    preflighted_refs = ",".join(
+        [entry.ref for entry in config.entries if entry.preflighted]
+    )
+    accepted = ",".join(config.constraints.accept)
+    accept = f'accept="{accepted}"' if accepted else ""
+    multiple = "multiple" if config.constraints.max_files > 1 else ""
+
+    return Markup(
+        f"""
+       <input type="file" id="{config.ref}" name="{config.name}"
+               data-phx-upload-ref="{config.ref}"
+               data-phx-active-refs="{active_refs}"
+               data-phx-done-refs="{done_refs}"
+               data-phx-preflighted-refs="{preflighted_refs}"
+               data-phx-update="ignore" phx-hook="Phoenix.LiveFileUpload"
+               {accept} {multiple}>
+            </input>
+        """
+    )
+
+
+@filters.register
+def upload_preview_tag(entry: UploadEntry) -> Markup:
+    config_ref = entry.upload_config.ref if entry.upload_config else ""
+    return Markup(
+        f"""<img id="phx-preview-{entry.ref}" data-phx-upload-ref="{config_ref}"
+            data-phx-entry-ref="{entry.ref}" data-phx-hook="Phoenix.LiveImgPreview" data-phx-update="ignore" />
+        """
+    )

pyview/ws_handler.py

@@ -1,12 +1,13 @@
 from typing import Optional
-from fastapi import WebSocket, WebSocketDisconnect
 import json
+from starlette.websockets import WebSocket, WebSocketDisconnect
 from urllib.parse import urlparse, parse_qs
 from pyview.live_socket import LiveViewSocket
 from pyview.live_routes import LiveViewLookup
 from pyview.csrf import validate_csrf_token
 from pyview.session import deserialize_session
 from pyview.auth import AuthProviderFactory
+from pyview.phx_message import parse_message
 
 
 class AuthException(Exception):
@@ -37,6 +38,8 @@ class LiveSocketHandler:
                 if not validate_csrf_token(payload["params"]["_csrf_token"], topic):
                     raise AuthException("Invalid CSRF token")
 
+                self.myJoinId = topic
+
                 url = urlparse(payload["url"])
                 lv = self.routes.get(url.path)
                 await self.check_auth(websocket, lv)
@@ -60,7 +63,7 @@ class LiveSocketHandler:
                 ]
 
                 await self.manager.send_personal_message(json.dumps(resp), websocket)
-                await self.handle_connected(socket)
+                await self.handle_connected(topic, socket)
 
         except WebSocketDisconnect:
             if socket:
@@ -70,10 +73,10 @@ class LiveSocketHandler:
             await websocket.close()
             self.sessions -= 1
 
-    async def handle_connected(self, socket: LiveViewSocket):
+    async def handle_connected(self, myJoinId, socket: LiveViewSocket):
         while True:
-            data = await socket.websocket.receive_text()
-            [joinRef, mesageRef, topic, event, payload] = json.loads(data)
+            message = await socket.websocket.receive()
+            [joinRef, mesageRef, topic, event, payload] = parse_message(message)
 
             if event == "heartbeat":
                 resp = [
@@ -83,25 +86,37 @@ class LiveSocketHandler:
                     "phx_reply",
                     {"response": {}, "status": "ok"},
                 ]
-                await self.manager.send_personal_message(json.dumps(resp), socket.websocket)
+                await self.manager.send_personal_message(
+                    json.dumps(resp), socket.websocket
+                )
                 continue
 
             if event == "event":
                 value = payload["value"]
+
                 if payload["type"] == "form":
                     value = parse_qs(value)
+                    socket.upload_manager.maybe_process_uploads(value, payload)
 
                 await socket.liveview.handle_event(payload["event"], value, socket)
                 rendered = await _render(socket)
 
+                hook_events = (
+                    {} if not socket.pending_events else {"e": socket.pending_events}
+                )
+
+                socket.pending_events = []
+
                 resp = [
                     joinRef,
                     mesageRef,
                     topic,
                     "phx_reply",
-                    {"response": {"diff": rendered}, "status": "ok"},
+                    {"response": {"diff": rendered | hook_events}, "status": "ok"},
                 ]
-                await self.manager.send_personal_message(json.dumps(resp), socket.websocket)
+                await self.manager.send_personal_message(
+                    json.dumps(resp), socket.websocket
+                )
                 continue
 
             if event == "live_patch":
@@ -118,9 +133,94 @@ class LiveSocketHandler:
                     "phx_reply",
                     {"response": {"diff": rendered}, "status": "ok"},
                 ]
-                await self.manager.send_personal_message(json.dumps(resp), socket.websocket)
+                await self.manager.send_personal_message(
+                    json.dumps(resp), socket.websocket
+                )
+                continue
+
+            if event == "allow_upload":
+                allow_upload_response = socket.upload_manager.process_allow_upload(
+                    payload
+                )
+                rendered = await _render(socket)
+
+                resp = [
+                    joinRef,
+                    mesageRef,
+                    topic,
+                    "phx_reply",
+                    {
+                        "response": {"diff": rendered} | allow_upload_response,
+                        "status": "ok",
+                    },
+                ]
+
+                await self.manager.send_personal_message(
+                    json.dumps(resp), socket.websocket
+                )
                 continue
 
+            # file upload
+            if event == "phx_join":
+                socket.upload_manager.add_upload(joinRef, payload)
+
+                resp = [
+                    joinRef,
+                    mesageRef,
+                    topic,
+                    "phx_reply",
+                    {"response": {}, "status": "ok"},
+                ]
+
+                await self.manager.send_personal_message(
+                    json.dumps(resp), socket.websocket
+                )
+
+            if event == "chunk":
+                socket.upload_manager.add_chunk(joinRef, payload)  # type: ignore
+
+                resp = [
+                    joinRef,
+                    mesageRef,
+                    topic,
+                    "phx_reply",
+                    {"response": {}, "status": "ok"},
+                ]
+
+                if socket.upload_manager.no_progress(joinRef):
+                    await self.manager.send_personal_message(
+                        json.dumps(
+                            [
+                                joinRef,
+                                None,
+                                myJoinId,
+                                "phx_reply",
+                                {"response": {"diff": {}}, "status": "ok"},
+                            ]
+                        ),
+                        socket.websocket,
+                    )
+
+                await self.manager.send_personal_message(
+                    json.dumps(resp), socket.websocket
+                )
+
+            if event == "progress":
+                socket.upload_manager.update_progress(joinRef, payload)
+                rendered = await _render(socket)
+
+                resp = [
+                    joinRef,
+                    mesageRef,
+                    topic,
+                    "phx_reply",
+                    {"response": {"diff": rendered}, "status": "ok"},
+                ]
+
+                await self.manager.send_personal_message(
+                    json.dumps(resp), socket.websocket
+                )
+
 
 async def _render(socket: LiveViewSocket):
     rendered = (await socket.liveview.render(socket.context)).tree()

{pyview_web-0.0.9a0.dist-info → pyview_web-0.0.20.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: pyview-web
-Version: 0.0.9a0
+Version: 0.0.20
 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.16,<4.0.0
+Requires-Python: >=3.9,<3.12
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Web Environment
 Classifier: Framework :: AsyncIO
@@ -20,11 +20,10 @@ 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: Programming Language :: Python :: 3.9
 Classifier: Topic :: Internet
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
@@ -34,10 +33,11 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Dist: APScheduler (==3.9.1.post1)
-Requires-Dist: fastapi (==0.111.0)
 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: wsproto (==1.2.0)
 Project-URL: Repository, https://github.com/ogrodnek/pyview
@@ -72,6 +72,7 @@ cookiecutter gh:ogrodnek/pyview-cookiecutter
 ## Other Examples
 
 - [pyview AI chat](https://github.com/pyview/pyview-example-ai-chat)
+- [pyview auth example](https://github.com/pyview/pyview-example-auth) (using [authlib](https://docs.authlib.org/en/latest/))
 
 ## Simple Counter
 
@@ -124,7 +125,7 @@ count.html:
 ## Additional Thanks
 
 - We're using the [pubsub implementation from flet](https://github.com/flet-dev/flet)
-- PyView is built on top of [FastAPI](https://fastapi.tiangolo.com), and of course, [Starlette](https://www.starlette.io/).
+- PyView is built on top of [Starlette](https://www.starlette.io/).
 
 # Status
 

{pyview_web-0.0.9a0.dist-info → pyview_web-0.0.20.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pyview/__init__.py,sha256=MN3RrkiFdM6bOZV6qJgvwifXV81Qx9k_PN2p8zJvq2I,223
-pyview/assets/js/app.js,sha256=n7FiM_VoxZ3ZUkLjtyxbOnSZU88zZkN1A5b8jjhiFoo,2508
+pyview/__init__.py,sha256=Pk-RgSkIG6fkLH3CwrF5tptoq7n72w0O73k2vAW4CAQ,374
+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
 pyview/auth/__init__.py,sha256=vMlirETRhD4va61NOzwg8VY8ep9wVOF96GznJGBmzD0,109
@@ -11,17 +11,19 @@ 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=p3eTynzGtvLiooOZyTemmXTrusAJKaoueuZ6Q5gfeYk,3314
-pyview/live_view.py,sha256=RRhj89NMianv6dkYd9onOQEJgpRF-pqUb7nmbQr6R6E,1255
-pyview/pyview.py,sha256=LdW2irgsd4KRls5TLU22DZJIy5Pmo_2L-ajOwXi9cEs,2302
+pyview/live_socket.py,sha256=6SLEkEBzK-zIUNh_5j_OG5t6IHGTDNCpGXk7D7SMNJ4,4370
+pyview/live_view.py,sha256=SeZ78aA_leqfubPUybRaaCUhqLJJirjPSkf9omvJyTs,1486
+pyview/phx_message.py,sha256=DUdPfl6tlw9K0FNXJ35ehq03JGgynvwA_JItHQ_dxMQ,2007
+pyview/pyview.py,sha256=UfVaYBAzPU_RalijjmXup6oDpIG_w9acjUG1AXm11r4,2342
 pyview/secret.py,sha256=HbaNpGAkFs4uxMVAmk9HwE3FIehg7dmwEOlED7C9moM,363
 pyview/session.py,sha256=nC8ExyVwfCgQfx9T-aJGyFhr2C7jsrEY_QFkaXtP28U,432
-pyview/static/assets/app.js,sha256=vyD-RACuZxOBWGy7VD-BY5-qkgbFyJM43-M-WGgaAHo,199984
+pyview/static/assets/app.js,sha256=QoXfdcOCYwVYJftvjsIIVwFye7onaOJMxRpalyYqoMU,200029
 pyview/template/__init__.py,sha256=bDaxDV7QhUwBXfy672Ft0NBDNvhT4kEKDV5VUWhADe8,206
 pyview/template/live_template.py,sha256=wSKyBw7ejpUY5qXUZdE36Jeeix8Of0CUq8eZdQwxXyg,1864
-pyview/template/root_template.py,sha256=0U50QIBhLVshLEog0SCbTDWgRjMpkfNDVcqowKFmGSQ,1876
+pyview/template/root_template.py,sha256=OBTYtaw03yDJIsXDV9ZFqy__U579FGttRjlAXnLaNEo,1882
 pyview/template/serializer.py,sha256=WDZfqJr2LMlf36fUW2CmWc2aREc63553_y_GRP2-qYc,826
 pyview/test_csrf.py,sha256=QWTOtfagDMkoYDK_ehYxua34F7-ltPsSeTwQGEOlqHU,684
+pyview/uploads.py,sha256=cFNOlJD5dkA2VccZT_W1bJn_5vYAaphhRJX-RCfEXm8,9598
 pyview/vendor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyview/vendor/flet/pubsub/__init__.py,sha256=JSPCeKB26b5E-IVHNRvVHrlf_CBGDLCulE9ADrostGs,39
 pyview/vendor/flet/pubsub/pub_sub.py,sha256=gpdruSxKQBqL7_Dtxo4vETm1kM0YH7S299msw2oyUoE,10184
@@ -35,8 +37,8 @@ pyview/vendor/ibis/nodes.py,sha256=jNRmlTCHXC4xCF8nfDRlLWINlaYiFa8NGrzebJFJgEM,2
 pyview/vendor/ibis/template.py,sha256=IX9z-Ig13yJyRnMqtB52eiRLe002qdIxnfa7fYEXLqM,2314
 pyview/vendor/ibis/tree.py,sha256=5LAjl3q9iPMZBb6QbKurWj9-QGKLVf11K2_bQotWlUc,2293
 pyview/vendor/ibis/utils.py,sha256=nLSaxPR9vMphzV9qinlz_Iurv9c49Ps6Knv8vyNlewU,2768
-pyview/ws_handler.py,sha256=tokN9gtC_Gn1tlPTxfhYGSFfquiSUvD3sHigzjh1gYM,4738
-pyview_web-0.0.9a0.dist-info/LICENSE,sha256=M_bADaBm9_MV9llX3lCicksLhwk3eZUjA2srE0uUWr0,1071
-pyview_web-0.0.9a0.dist-info/METADATA,sha256=A5xUGWuuj2y8FvzoqsSynuwkD3osTc2ZO1HWzYzUm2U,5220
-pyview_web-0.0.9a0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pyview_web-0.0.9a0.dist-info/RECORD,,
+pyview/ws_handler.py,sha256=Mkbw6UKEy4HYURSZUdmpF95oWiuEymzS_VGG8WV8mGw,7977
+pyview_web-0.0.20.dist-info/LICENSE,sha256=M_bADaBm9_MV9llX3lCicksLhwk3eZUjA2srE0uUWr0,1071
+pyview_web-0.0.20.dist-info/METADATA,sha256=6EY-yiCteR7fFY029hG2T5jCp8wCMRKpr2FaGhV8tJY,5276
+pyview_web-0.0.20.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pyview_web-0.0.20.dist-info/RECORD,,