pyview-web 0.7.2__tar.gz

pyview_web-0.7.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Larry Ogrodnek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyview_web-0.7.2/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: pyview-web
+Version: 0.7.2
+Summary: LiveView in Python
+License: MIT
+License-File: LICENSE
+Keywords: web,api,LiveView
+Author: Larry Ogrodnek
+Author-email: ogrodnek@gmail.com
+Requires-Python: >=3.11,<3.15
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Pydantic
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+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.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Internet
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: APScheduler (>=3.11.0,<4.0.0)
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: itsdangerous (>=2.2.0,<3.0.0)
+Requires-Dist: markupsafe (>=3.0.2,<4.0.0)
+Requires-Dist: pydantic (>=2.11,<3.0)
+Requires-Dist: starlette (>=0.50.0,<0.51.0)
+Requires-Dist: wsproto (>=1.3.0,<2.0.0)
+Project-URL: Homepage, https://pyview.rocks
+Project-URL: Repository, https://github.com/ogrodnek/pyview
+Description-Content-Type: text/markdown
+
+<img src="https://pyview.rocks/images/pyview_logo_512.png" width="128px" align="right" />
+
+# PyView
+
+> A Python implementation of Phoenix LiveView
+
+PyView enables dynamic, real-time web apps, using server-rendered HTML.
+
+**Source Code**: <a href="https://github.com/ogrodnek/pyview" target="_blank">https://github.com/ogrodnek/pyview</a>
+
+# Installation
+
+`pip install pyview-web`
+
+## Quickstart
+
+There's a [cookiecutter](https://github.com/cookiecutter/cookiecutter) template available
+
+```
+cookiecutter gh:ogrodnek/pyview-cookiecutter
+```
+
+# Live Examples
+
+[https://examples.pyview.rocks/](https://examples.pyview.rocks/)
+
+## 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
+
+[See it live!](https://examples.pyview.rocks/count)
+
+count.py:
+
+```python
+from pyview import LiveView, LiveViewSocket
+from typing import TypedDict
+
+
+class CountContext(TypedDict):
+    count: int
+
+
+class CountLiveView(LiveView[CountContext]):
+    async def mount(self, socket: LiveViewSocket[CountContext], _session):
+        socket.context = {"count": 0}
+
+    async def handle_event(self, event, payload, socket: LiveViewSocket[CountContext]):
+        if event == "decrement":
+            socket.context["count"] -= 1
+
+        if event == "increment":
+            socket.context["count"] += 1
+
+    async def handle_params(self, url, params, socket: LiveViewSocket[CountContext]):
+        if "c" in params:
+            socket.context["count"] = int(params["c"][0])
+```
+
+count.html:
+
+```html
+<div>
+  <h1>Count is {{count}}</h1>
+  <button phx-click="decrement">-</button>
+  <button phx-click="increment">+</button>
+</div>
+```
+
+# Acknowledgements
+
+- Obviously this project wouldn't exist without [Phoenix LiveView](https://github.com/phoenixframework/phoenix_live_view), which is a wonderful paradigm and implementation. Besides using their ideas, we also directly use the LiveView JavaScript code.
+- Thanks to [Donnie Flood](https://github.com/floodfx) for the encouragement, inspiration, help, and even pull requests to get this project started! Check out [LiveViewJS](https://github.com/floodfx/liveviewjs) for a TypeScript implementation of LiveView (that's much more mature than this one!)
+
+- Thanks to [Darren Mulholland](https://github.com/dmulholl) for both his [Let's Build a Template Language](https://www.dmulholl.com/lets-build/a-template-language.html) tutorial, as well as his [ibis template engine](https://github.com/dmulholl/ibis), which he very generously released into the public domain, and forms the basis of templating in PyView.
+
+## Additional Thanks
+
+- We're using the [pubsub implementation from flet](https://github.com/flet-dev/flet)
+- PyView is built on top of [Starlette](https://www.starlette.io/).
+
+# Status
+
+PyView is in the very early stages of active development. Please check it out and give feedback! Note that the API is likely to change, and there are many features that are not yet implemented.
+
+# Running the included Examples
+
+## Setup
+
+```
+poetry install
+```
+
+## Running
+
+```
+poetry run uvicorn examples.app:app --reload
+```
+
+Then go to http://localhost:8000/
+
+### Poetry Install
+
+```
+brew install pipx
+pipx install poetry
+pipx ensurepath
+```
+
+(see https://python-poetry.org/docs/#installation for more details)
+
+# License
+
+PyView is licensed under the [MIT License](LICENSE).
+

pyview_web-0.7.2/pyproject.toml

@@ -0,0 +1,136 @@
+[tool.poetry]
+name = "pyview-web"
+
+packages = [
+  { include = "pyview" },
+]
+
+version = "0.7.2"
+description = "LiveView in Python"
+authors = ["Larry Ogrodnek <ogrodnek@gmail.com>"]
+license = "MIT"
+readme = "readme.md"
+homepage = "https://pyview.rocks"
+repository = "https://github.com/ogrodnek/pyview"
+keywords = ["web", "api", "LiveView"]
+
+classifiers = [
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: System Administrators",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python",
+    "Topic :: Internet",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development",
+    "Typing :: Typed",
+    "Development Status :: 4 - Beta",
+    "Environment :: Web Environment",
+    "Framework :: AsyncIO",
+    "Framework :: Pydantic",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    "Topic :: Internet :: WWW/HTTP",
+]
+
+[tool.poetry.dependencies]
+python = ">=3.11,<3.15"
+starlette = "^0.50.0"
+wsproto = "^1.3.0"
+APScheduler = "^3.11.0"
+markupsafe = "^3.0.2"
+itsdangerous = "^2.2.0"
+pydantic = "^2.11"
+click = "^8.1.7"
+
+[tool.poetry.scripts]
+pv = "pyview.cli.main:cli"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.2.0"
+ruff = "^0.14.0"
+pyright = "^1.1.403"
+pytest-cov = "^6.1.1"
+pytest-asyncio = "^1.3.0"
+
+[tool.poetry.group.profiling.dependencies]
+scalene = {version = "^1.5.51", python = "!=3.11.0,>=3.11"}
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pyright]
+exclude = [
+    ".venv",
+    "examples",
+    "examples/.venv",
+    "**/vendor",
+    "**/node_modules",
+    "**/__pycache__",
+    # T-string files require Python 3.14+
+    "tests/test_live_view_template.py",
+    "tests/test_template_view.py",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+exclude = [
+    # T-string files require Python 3.14+ syntax
+    "pyview/template/__init__.py",
+    "pyview/template/template_view.py",
+    "pyview/template/live_view_template.py",
+    "examples/views/count/count_tstring.py",
+    "tests/test_live_view_template.py",
+    "tests/test_template_view.py",
+]
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle errors
+    "W",   # pycodestyle warnings
+    "F",   # pyflakes
+    "I",   # isort
+    "N",   # pep8-naming
+    "UP",  # pyupgrade
+    "B",   # flake8-bugbear
+    "C4",  # flake8-comprehensions
+    "SIM", # flake8-simplify
+]
+ignore = [
+    "E501",   # line too long (handled by formatter)
+    "UP007",  # use-pep604-annotation (Union[X, Y] -> X | Y)
+    "UP035",  # deprecated-import (keep typing.Iterator instead of collections.abc.Iterator)
+    "UP045",  # non-pep604-annotation (keep Optional[X] instead of X | None)
+    "N802",   # mixed case function names
+    "N803",   # mixed case variable
+    "N806",   # mixed case variable in function
+    "N815",   # mixed case attributes
+    "N818",   # exception naming (keep AuthException, not AuthError)
+    "N999",   # invalid module name (allow PascalCase module names)
+    "SIM108", # prefer if-else blocks over ternary operators for readability
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["pyview"]
+
+[tool.ruff.lint.per-file-ignores]
+"pyview/vendor/**" = ["E722", "F811", "N818", "SIM102", "SIM103", "SIM118", "UP031"]  # Ignore vendored code issues
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+line-ending = "auto"

pyview_web-0.7.2/pyview/__init__.py

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

pyview_web-0.7.2/pyview/assets/js/app.js

@@ -0,0 +1,79 @@
+// We import the CSS which is extracted to its own file by esbuild.
+// Remove this line if you add a your own CSS build pipeline (e.g postcss).
+//import "../css/app.css";
+
+// If you want to use Phoenix channels, run `mix help phx.gen.channel`
+// to get started and then uncomment the line below.
+// import "./user_socket.js"
+
+// You can include dependencies in two ways.
+//
+// The simplest option is to put them in assets/vendor and
+// import them using relative paths:
+//
+//     import "./vendor/some-package.js"
+//
+// Alternatively, you can `npm install some-package` and import
+// them using a path starting with the package name:
+//
+//     import "some-package"
+//
+
+// Include phoenix_html to handle method=PUT/DELETE in forms and buttons.
+import "phoenix_html";
+// Establish Phoenix Socket and LiveView configuration.
+import { Socket } from "phoenix";
+import { LiveSocket } from "phoenix_live_view";
+import NProgress from "nprogress";
+
+let Hooks = window.Hooks ?? {};
+
+let scrollAt = () => {
+  let scrollTop = document.documentElement.scrollTop || document.body.scrollTop;
+  let scrollHeight =
+    document.documentElement.scrollHeight || document.body.scrollHeight;
+  let clientHeight = document.documentElement.clientHeight;
+
+  return (scrollTop / (scrollHeight - clientHeight)) * 100;
+};
+
+Hooks.InfiniteScroll = {
+  page() {
+    return this.el.dataset.page;
+  },
+  mounted() {
+    this.pending = this.page();
+    window.addEventListener("scroll", (e) => {
+      if (this.pending == this.page() && scrollAt() > 90) {
+        this.pending = this.page() + 1;
+        this.pushEvent("load-more", {});
+      }
+    });
+  },
+  updated() {
+    this.pending = this.page();
+  },
+};
+
+let csrfToken = document
+  .querySelector("meta[name='csrf-token']")
+  .getAttribute("content");
+let liveSocket = new LiveSocket("/live", Socket, {
+  hooks: Hooks,
+  params: { _csrf_token: csrfToken },
+  uploaders: window.Uploaders || {},
+});
+
+// Show progress bar on live navigation and form submits
+//topbar.config({ barColors: { 0: "#29d" }, shadowColor: "rgba(0, 0, 0, .3)" });
+window.addEventListener("phx:page-loading-start", (info) => NProgress.start());
+window.addEventListener("phx:page-loading-stop", (info) => NProgress.done());
+
+// connect if there are any LiveViews on the page
+liveSocket.connect();
+
+// expose liveSocket on window for web console debug logs and latency simulation:
+// >> liveSocket.enableDebug()
+// >> liveSocket.enableLatencySim(1000)  // enabled for duration of browser session
+// >> liveSocket.disableLatencySim()
+window.liveSocket = liveSocket;

pyview_web-0.7.2/pyview/assets/js/uploaders.js

@@ -0,0 +1,221 @@
+/**
+ * PyView External S3 Uploaders
+ *
+ * Client-side uploaders for external S3 uploads.
+ *
+ * Available uploaders:
+ * - S3: Simple POST upload to S3 using presigned POST URLs
+ * - S3Multipart: Multipart upload for large files (>5GB)
+ */
+
+window.Uploaders = window.Uploaders || {};
+
+// S3 Simple POST uploader
+// Uses presigned POST URLs for direct upload to S3
+// Works for files up to ~5GB
+if (!window.Uploaders.S3) {
+  window.Uploaders.S3 = function (entries, onViewError) {
+    entries.forEach((entry) => {
+      let formData = new FormData();
+      let { url, fields } = entry.meta;
+
+      // Add all fields from presigned POST
+      Object.entries(fields).forEach(([key, val]) =>
+        formData.append(key, val)
+      );
+      formData.append("file", entry.file);
+
+      let xhr = new XMLHttpRequest();
+      onViewError(() => xhr.abort());
+
+      xhr.onload = () => {
+        if (xhr.status === 204 || xhr.status === 200) {
+          entry.progress(100);
+        } else {
+          entry.error(`S3 upload failed with status ${xhr.status}`);
+        }
+      };
+      xhr.onerror = () => entry.error("Network error during upload");
+
+      xhr.upload.addEventListener("progress", (event) => {
+        if (event.lengthComputable) {
+          let percent = Math.round((event.loaded / event.total) * 100);
+          if (percent < 100) {
+            entry.progress(percent);
+          }
+        }
+      });
+
+      xhr.open("POST", url, true);
+      xhr.send(formData);
+    });
+  };
+}
+
+// S3 Multipart uploader for large files
+// Uploads file in chunks with retry logic and concurrency control
+//
+// - Exponential backoff retry (max 3 attempts per part)
+// - Concurrency limit (max 6 parallel uploads)
+// - Automatic cleanup on fatal errors
+//
+// Based on AWS best practices:
+// https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html
+//
+// Server must:
+// 1. Return metadata with: uploader="S3Multipart", upload_id, part_urls, chunk_size
+// 2. Provide entry_complete callback to finalize the upload
+if (!window.Uploaders.S3Multipart) {
+  window.Uploaders.S3Multipart = function (entries, onViewError) {
+    entries.forEach((entry) => {
+      const { upload_id, part_urls, chunk_size, key } = entry.meta;
+      const file = entry.file;
+      const parts = []; // Store {PartNumber, ETag} for each uploaded part
+
+      const MAX_RETRIES = 3;
+      const MAX_CONCURRENT = 6;
+      let uploadedParts = 0;
+      let activeUploads = 0;
+      let partIndex = 0;
+      let hasError = false;
+      const totalParts = part_urls.length;
+
+      console.log(`[S3Multipart] Starting upload for ${entry.file.name}`);
+      console.log(`[S3Multipart] Total parts: ${totalParts}, chunk size: ${chunk_size}`);
+      console.log(`[S3Multipart] Max concurrent uploads: ${MAX_CONCURRENT}, max retries: ${MAX_RETRIES}`);
+
+      // Add a custom method to send completion data directly
+      // This bypasses entry.progress() which only handles numbers
+      entry.complete = function(completionData) {
+        console.log(`[S3Multipart] Calling entry.complete with:`, completionData);
+        // Call pushFileProgress directly with the completion data
+        entry.view.pushFileProgress(entry.fileEl, entry.ref, completionData);
+      };
+
+      // Upload a single part with retry logic
+      const uploadPart = (index, retryCount = 0) => {
+        if (hasError) return;  // Stop if we've hit a fatal error
+
+        const partNumber = index + 1;
+        const url = part_urls[index];
+        const start = index * chunk_size;
+        const end = Math.min(start + chunk_size, file.size);
+        const chunk = file.slice(start, end);
+
+        console.log(`[S3Multipart] Starting part ${partNumber}/${totalParts}, size: ${chunk.size} bytes, attempt ${retryCount + 1}`);
+
+        const xhr = new XMLHttpRequest();
+        onViewError(() => xhr.abort());
+
+        // Track upload progress within this chunk
+        xhr.upload.addEventListener("progress", (event) => {
+          if (event.lengthComputable) {
+            // Calculate overall progress: completed parts + current part's progress
+            const completedBytes = uploadedParts * chunk_size;
+            const currentPartBytes = event.loaded;
+            const totalBytes = file.size;
+            const overallPercent = Math.round(((completedBytes + currentPartBytes) / totalBytes) * 100);
+
+            // Don't report 100% until all parts complete and we send completion data
+            if (overallPercent < 100) {
+              entry.progress(overallPercent);
+            }
+          }
+        });
+
+        xhr.onload = () => {
+          activeUploads--;
+
+          if (xhr.status === 200) {
+            const etag = xhr.getResponseHeader('ETag');
+            console.log(`[S3Multipart] Part ${partNumber} succeeded, ETag: ${etag}`);
+
+            if (!etag) {
+              console.error(`[S3Multipart] Part ${partNumber} missing ETag!`);
+              entry.error(`Part ${partNumber} upload succeeded but no ETag returned`);
+              hasError = true;
+              return;
+            }
+
+            // Store the part with its ETag
+            parts.push({
+              PartNumber: partNumber,
+              ETag: etag.replace(/"/g, '')
+            });
+            uploadedParts++;
+
+            // Update progress
+            const progressPercent = Math.round((uploadedParts / totalParts) * 100);
+            console.log(`[S3Multipart] Progress: ${uploadedParts}/${totalParts} parts (${progressPercent}%)`);
+
+            if (uploadedParts < totalParts) {
+              entry.progress(progressPercent < 100 ? progressPercent : 99);
+              uploadNextPart();  // Start next part
+            } else {
+              // All parts complete!
+              const completionData = {
+                complete: true,
+                upload_id: upload_id,
+                key: key,
+                parts: parts.sort((a, b) => a.PartNumber - b.PartNumber)
+              };
+              console.log(`[S3Multipart] All parts complete! Sending completion data`);
+              entry.complete(completionData);
+            }
+          } else {
+            // Upload failed - retry with exponential backoff
+            console.error(`[S3Multipart] Part ${partNumber} failed with status ${xhr.status}, attempt ${retryCount + 1}`);
+
+            if (retryCount < MAX_RETRIES) {
+              // Exponential backoff: 1s, 2s, 4s, max 10s
+              const delay = Math.min(1000 * (2 ** retryCount), 10000);
+              console.log(`[S3Multipart] Retrying part ${partNumber} in ${delay}ms...`);
+
+              setTimeout(() => {
+                uploadPart(index, retryCount + 1);
+              }, delay);
+            } else {
+              // Max retries exceeded - fatal error
+              console.error(`[S3Multipart] Part ${partNumber} failed after ${MAX_RETRIES} retries, aborting upload`);
+              entry.error(`Part ${partNumber} failed after ${MAX_RETRIES} attempts. Upload aborted.`);
+              hasError = true;
+            }
+          }
+        };
+
+        xhr.onerror = () => {
+          activeUploads--;
+          console.error(`[S3Multipart] Network error on part ${partNumber}, attempt ${retryCount + 1}`);
+
+          if (retryCount < MAX_RETRIES) {
+            const delay = Math.min(1000 * (2 ** retryCount), 10000);
+            console.log(`[S3Multipart] Retrying part ${partNumber} after network error in ${delay}ms...`);
+
+            setTimeout(() => {
+              uploadPart(index, retryCount + 1);
+            }, delay);
+          } else {
+            console.error(`[S3Multipart] Part ${partNumber} network error after ${MAX_RETRIES} retries, aborting upload`);
+            entry.error(`Part ${partNumber} network error after ${MAX_RETRIES} attempts. Upload aborted.`);
+            hasError = true;
+          }
+        };
+
+        xhr.open('PUT', url, true);
+        xhr.send(chunk);
+        activeUploads++;
+      };
+
+      // Upload next part if we haven't hit the concurrency limit
+      const uploadNextPart = () => {
+        while (partIndex < totalParts && activeUploads < MAX_CONCURRENT && !hasError) {
+          uploadPart(partIndex);
+          partIndex++;
+        }
+      };
+
+      // Start initial batch of uploads
+      uploadNextPart();
+    });
+  };
+}