pyview-web 0.0.9a0__tar.gz → 0.0.21__tar.gz

{pyview_web-0.0.9a0 → pyview_web-0.0.21}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: pyview-web
-Version: 0.0.9a0
+Version: 0.0.21
 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 → pyview_web-0.0.21}/pyproject.toml

@@ -5,7 +5,7 @@ packages = [
   { include = "pyview" },
 ]
 
-version = "0.0.9a"
+version = "0.0.21"
 description = "LiveView in Python"
 authors = ["Larry Ogrodnek <ogrodnek@gmail.com>"]
 license = "MIT"
@@ -42,17 +42,18 @@ classifiers = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.9.16"
-fastapi = "0.111.0"
+python = ">=3.9,<3.12"
+starlette = "0.37.2"
 uvicorn = "0.20.0"
 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"
 
 [tool.poetry.group.dev.dependencies]
-pytest = "^6.0.0"
+pytest = "^7.2.0"
 black = "24.3.0"
 pyright = "1.1.292"
 aiohttp = "^3.8.4"

{pyview_web-0.0.9a0 → pyview_web-0.0.21}/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_web-0.0.9a0 → pyview_web-0.0.21}/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_web-0.0.9a0 → pyview_web-0.0.21}/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_web-0.0.9a0 → pyview_web-0.0.21}/pyview/live_view.py

@@ -1,14 +1,23 @@
 from typing import TypeVar, Generic, Optional, Union, Any
 from .live_socket import LiveViewSocket, UnconnectedSocket
-from pyview.template import LiveTemplate, template_file, RenderedContent, LiveRender
-import inspect
+from pyview.template import (
+    LiveTemplate,
+    template_file,
+    RenderedContent,
+    LiveRender,
+    find_associated_file,
+)
 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 +32,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:
@@ -36,11 +48,6 @@ class LiveView(Generic[T]):
 
 
 def _find_render(m: LiveView) -> Optional[LiveTemplate]:
-    cf = inspect.getfile(m.__class__)
-    return _find_template(cf)
-
-
-def _find_template(cf: str) -> Optional[LiveTemplate]:
-    if cf.endswith(".py"):
-        cf = cf[:-3]
-        return template_file(cf + ".html")
+    html = find_associated_file(m, ".html")
+    if html is not None:
+        return template_file(html)

pyview_web-0.0.21/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_web-0.0.9a0 → pyview_web-0.0.21}/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
@@ -14,7 +14,12 @@ from pyview.auth import AuthProviderFactory
 from .ws_handler import LiveSocketHandler
 from .live_view import LiveView
 from .live_routes import LiveViewLookup
-from .template import RootTemplate, RootTemplateContext, defaultRootTemplate
+from .template import (
+    RootTemplate,
+    RootTemplateContext,
+    defaultRootTemplate,
+    find_associated_css,
+)
 
 
 class PyView(Starlette):
@@ -54,9 +59,11 @@ 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)
 
+    liveview_css = find_associated_css(lv)
+
     id = str(uuid.uuid4())
 
     context: RootTemplateContext = {
@@ -65,6 +72,7 @@ async def liveview_container(
         "title": s.live_title,
         "csrf_token": generate_csrf_token("lv:phx-" + id),
         "session": serialize_session(session),
+        "additional_head_elements": liveview_css,
     }
 
     return HTMLResponse(template(context))

{pyview_web-0.0.9a0 → pyview_web-0.0.21}/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_web-0.0.21/pyview/template/__init__.py

@@ -0,0 +1,17 @@
+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
+
+__all__ = [
+    "Template",
+    "LiveTemplate",
+    "template_file",
+    "RenderedContent",
+    "LiveRender",
+    "RootTemplate",
+    "RootTemplateContext",
+    "defaultRootTemplate",
+    "find_associated_css",
+    "find_associated_file",
+]

{pyview_web-0.0.9a0 → pyview_web-0.0.21}/pyview/template/root_template.py

@@ -8,6 +8,7 @@ class RootTemplateContext(TypedDict):
     title: Optional[str]
     csrf_token: str
     session: Optional[str]
+    additional_head_elements: list[Markup]
 
 
 RootTemplate = Callable[[RootTemplateContext], str]
@@ -45,6 +46,8 @@ def _defaultRootTemplate(
         ),
     )
 
+    additional_head_elements = "\n".join(context["additional_head_elements"])
+
     return (
         Markup(
             f"""
@@ -56,8 +59,9 @@ 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">
-      <script defer type="text/javascript" src="/static/assets/app.js"></script>
       {css}
+      <script defer type="text/javascript" src="/static/assets/app.js"></script>
+      {additional_head_elements}
     </head>
     <body>"""
         )

pyview_web-0.0.21/pyview/template/utils.py

@@ -0,0 +1,24 @@
+from typing import Optional
+import inspect
+import os
+from markupsafe import Markup
+
+
+def find_associated_file(o: object, extension: str) -> Optional[str]:
+    object_file = inspect.getfile(o.__class__)
+
+    if object_file.endswith(".py"):
+        object_file = object_file[:-3]
+
+        associated_file = object_file + extension
+        if os.path.isfile(associated_file):
+            return associated_file
+
+
+def find_associated_css(o: object) -> list[Markup]:
+    css_file = find_associated_file(o, ".css")
+    if css_file:
+        with open(css_file, "r") as css:
+            return [Markup(f"<style>{css.read()}</style>")]
+
+    return []

pyview_web-0.0.21/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_web-0.0.9a0 → pyview_web-0.0.21}/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 → pyview_web-0.0.21}/readme.md

@@ -27,6 +27,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
 
@@ -79,7 +80,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/pyview/template/__init__.py

@@ -1,3 +0,0 @@
-from pyview.vendor.ibis import Template
-from .live_template import LiveTemplate, template_file, RenderedContent, LiveRender
-from .root_template import RootTemplate, RootTemplateContext, defaultRootTemplate